@graphql-eslint/eslint-plugin 3.19.3 → 3.20.0-alpha-20230703155329-a20556f

package/esm/siblings.js

@@ -1,109 +1,110 @@
-import { parseGraphQLSDL } from '@graphql-tools/utils';
-import { Kind, visit, } from 'graphql';
-import { getDocuments } from './documents.js';
-import { logger } from './utils.js';
-const siblingOperationsCache = new Map();
-export function getSiblings(project, documents) {
-    const siblings = project
-        ? getDocuments(project)
-        : typeof documents === 'string'
-            ? [parseGraphQLSDL('operation.graphql', documents, { noLocation: true })]
-            : [];
-    if (siblings.length === 0) {
-        let printed = false;
-        const noopWarn = () => {
-            if (!printed) {
-                logger.warn('getSiblingOperations was called without any operations. Make sure to set "parserOptions.operations" to make this feature available!');
-                printed = true;
-            }
-            return [];
-        };
-        return {
-            available: false,
-            getFragment: noopWarn,
-            getFragments: noopWarn,
-            getFragmentByType: noopWarn,
-            getFragmentsInUse: noopWarn,
-            getOperation: noopWarn,
-            getOperations: noopWarn,
-            getOperationByType: noopWarn,
-        };
+import { parseGraphQLSDL } from "@graphql-tools/utils";
+import {
+  Kind,
+  visit
+} from "graphql";
+import { getDocuments } from "./documents.js";
+import { logger } from "./utils.js";
+const siblingOperationsCache = /* @__PURE__ */ new Map();
+function getSiblings(project, documents) {
+  const siblings = project ? getDocuments(project) : typeof documents === "string" ? [parseGraphQLSDL("operation.graphql", documents, { noLocation: true })] : [];
+  if (siblings.length === 0) {
+    let printed = false;
+    const noopWarn = () => {
+      if (!printed) {
+        logger.warn(
+          'getSiblingOperations was called without any operations. Make sure to set "parserOptions.operations" to make this feature available!'
+        );
+        printed = true;
+      }
+      return [];
+    };
+    return {
+      available: false,
+      getFragment: noopWarn,
+      getFragments: noopWarn,
+      getFragmentByType: noopWarn,
+      getFragmentsInUse: noopWarn,
+      getOperation: noopWarn,
+      getOperations: noopWarn,
+      getOperationByType: noopWarn
+    };
+  }
+  const value = siblingOperationsCache.get(siblings);
+  if (value) {
+    return value;
+  }
+  let fragmentsCache = null;
+  const getFragments = () => {
+    if (fragmentsCache === null) {
+      const result = [];
+      for (const source of siblings) {
+        for (const definition of source.document?.definitions || []) {
+          if (definition.kind === Kind.FRAGMENT_DEFINITION) {
+            result.push({
+              filePath: source.location,
+              document: definition
+            });
+          }
+        }
+      }
+      fragmentsCache = result;
     }
-    // Since the siblings array is cached, we can use it as cache key.
-    // We should get the same array reference each time we get
-    // to this point for the same graphql project
-    const value = siblingOperationsCache.get(siblings);
-    if (value) {
-        return value;
+    return fragmentsCache;
+  };
+  let cachedOperations = null;
+  const getOperations = () => {
+    if (cachedOperations === null) {
+      const result = [];
+      for (const source of siblings) {
+        for (const definition of source.document?.definitions || []) {
+          if (definition.kind === Kind.OPERATION_DEFINITION) {
+            result.push({
+              filePath: source.location,
+              document: definition
+            });
+          }
+        }
+      }
+      cachedOperations = result;
     }
-    let fragmentsCache = null;
-    const getFragments = () => {
-        var _a;
-        if (fragmentsCache === null) {
-            const result = [];
-            for (const source of siblings) {
-                for (const definition of ((_a = source.document) === null || _a === void 0 ? void 0 : _a.definitions) || []) {
-                    if (definition.kind === Kind.FRAGMENT_DEFINITION) {
-                        result.push({
-                            filePath: source.location,
-                            document: definition,
-                        });
-                    }
-                }
-            }
-            fragmentsCache = result;
+    return cachedOperations;
+  };
+  const getFragment = (name) => getFragments().filter((f) => f.document.name.value === name);
+  const collectFragments = (selectable, recursive, collected = /* @__PURE__ */ new Map()) => {
+    visit(selectable, {
+      FragmentSpread(spread) {
+        const fragmentName = spread.name.value;
+        const [fragment] = getFragment(fragmentName);
+        if (!fragment) {
+          logger.warn(
+            `Unable to locate fragment named "${fragmentName}", please make sure it's loaded using "parserOptions.operations"`
+          );
+          return;
         }
-        return fragmentsCache;
-    };
-    let cachedOperations = null;
-    const getOperations = () => {
-        var _a;
-        if (cachedOperations === null) {
-            const result = [];
-            for (const source of siblings) {
-                for (const definition of ((_a = source.document) === null || _a === void 0 ? void 0 : _a.definitions) || []) {
-                    if (definition.kind === Kind.OPERATION_DEFINITION) {
-                        result.push({
-                            filePath: source.location,
-                            document: definition,
-                        });
-                    }
-                }
-            }
-            cachedOperations = result;
+        if (!collected.has(fragmentName)) {
+          collected.set(fragmentName, fragment.document);
+          if (recursive) {
+            collectFragments(fragment.document, recursive, collected);
+          }
         }
-        return cachedOperations;
-    };
-    const getFragment = (name) => getFragments().filter(f => f.document.name.value === name);
-    const collectFragments = (selectable, recursive, collected = new Map()) => {
-        visit(selectable, {
-            FragmentSpread(spread) {
-                const fragmentName = spread.name.value;
-                const [fragment] = getFragment(fragmentName);
-                if (!fragment) {
-                    logger.warn(`Unable to locate fragment named "${fragmentName}", please make sure it's loaded using "parserOptions.operations"`);
-                    return;
-                }
-                if (!collected.has(fragmentName)) {
-                    collected.set(fragmentName, fragment.document);
-                    if (recursive) {
-                        collectFragments(fragment.document, recursive, collected);
-                    }
-                }
-            },
-        });
-        return collected;
-    };
-    const siblingOperations = {
-        available: true,
-        getFragment,
-        getFragments,
-        getFragmentByType: typeName => getFragments().filter(f => f.document.typeCondition.name.value === typeName),
-        getFragmentsInUse: (selectable, recursive = true) => Array.from(collectFragments(selectable, recursive).values()),
-        getOperation: name => getOperations().filter(o => { var _a; return ((_a = o.document.name) === null || _a === void 0 ? void 0 : _a.value) === name; }),
-        getOperations,
-        getOperationByType: type => getOperations().filter(o => o.document.operation === type),
-    };
-    siblingOperationsCache.set(siblings, siblingOperations);
-    return siblingOperations;
+      }
+    });
+    return collected;
+  };
+  const siblingOperations = {
+    available: true,
+    getFragment,
+    getFragments,
+    getFragmentByType: (typeName) => getFragments().filter((f) => f.document.typeCondition.name.value === typeName),
+    getFragmentsInUse: (selectable, recursive = true) => Array.from(collectFragments(selectable, recursive).values()),
+    getOperation: (name) => getOperations().filter((o) => o.document.name?.value === name),
+    getOperations,
+    getOperationByType: (type) => getOperations().filter((o) => o.document.operation === type)
+  };
+  siblingOperationsCache.set(siblings, siblingOperations);
+  return siblingOperations;
 }
+export {
+  getSiblings
+};

package/esm/testkit.d.mts

@@ -0,0 +1,8 @@
+import 'eslint';
+import 'graphql';
+import './estree-converter/types.mjs';
+export { G as GraphQLESLintRuleListener, b as GraphQLInvalidTestCase, c as GraphQLRuleTester, a as GraphQLValidTestCase } from './types-2e1afd7c.js';
+import 'estree';
+import '@graphql-tools/utils';
+import 'graphql-config';
+import 'json-schema-to-ts';

package/esm/testkit.js

@@ -1,160 +1,151 @@
 import { createRequire } from 'module';
 const require = createRequire(import.meta.url);
-import { readFileSync } from 'fs';
-import { resolve } from 'path';
-import { codeFrameColumns } from '@babel/code-frame';
-import { Linter, RuleTester } from 'eslint';
+import { readFileSync } from "fs";
+import { resolve } from "path";
+import { codeFrameColumns } from "@babel/code-frame";
+import { Linter, RuleTester } from "eslint";
 function indentCode(code, indent = 4) {
-    return code.replace(/^/gm, ' '.repeat(indent));
+  return code.replace(/^/gm, " ".repeat(indent));
 }
-// A simple version of `SourceCodeFixer.applyFixes`
-// https://github.com/eslint/eslint/issues/14936#issuecomment-906746754
 function applyFix(code, { range, text }) {
-    return [code.slice(0, range[0]), text, code.slice(range[1])].join('');
+  return [code.slice(0, range[0]), text, code.slice(range[1])].join("");
 }
-export class GraphQLRuleTester extends RuleTester {
-    constructor(parserOptions = {}) {
-        const config = {
-            parser: require.resolve('@graphql-eslint/eslint-plugin'),
-            parserOptions: {
-                ...parserOptions,
-                skipGraphQLConfig: true,
-            },
-        };
-        super(config);
-        this.config = config;
-    }
-    fromMockFile(path) {
-        return readFileSync(resolve(__dirname, `../tests/mocks/${path}`), 'utf-8');
-    }
-    runGraphQLTests(ruleId, rule, tests) {
-        super.run(ruleId, rule, tests);
-        const linter = new Linter();
-        linter.defineRule(ruleId, rule);
-        const hasOnlyTest = [...tests.valid, ...tests.invalid].some(t => typeof t !== 'string' && t.only);
-        // for (const [index, testCase] of tests.valid.entries()) {
-        //   const { name, code, filename, only }: RuleTester.ValidTestCase =
-        //     typeof testCase === 'string' ? { code: testCase } : testCase;
-        //
-        //   if (hasOnlyTest && !only) {
-        //     continue;
-        //   }
-        //
-        //   const verifyConfig = getVerifyConfig<Options>(ruleId, this.config, testCase);
-        //   defineParser(linter, verifyConfig.parser);
-        //
-        //   const messages = linter.verify(code, verifyConfig, { filename });
-        //   const codeFrame = printCode(code, { line: 0, column: 0 });
-        //
-        //   it(name || `Valid #${index + 1}\n${codeFrame}`, () => {
-        //     expect(messages).toEqual([]);
-        //   });
-        // }
-        for (const [idx, testCase] of tests.invalid.entries()) {
-            const { only, filename, options, name } = testCase;
-            if (hasOnlyTest && !only) {
-                continue;
-            }
-            const code = removeTrailingBlankLines(testCase.code);
-            const verifyConfig = getVerifyConfig(ruleId, this.config, testCase);
-            defineParser(linter, verifyConfig.parser);
-            const messages = linter.verify(code, verifyConfig, filename);
-            if (messages.length === 0) {
-                throw new Error('Invalid case should have at least one error.');
-            }
-            const codeFrame = indentCode(printCode(code, { line: 0, column: 0 }));
-            const messageForSnapshot = ['#### ⌨️ Code', codeFrame];
-            if (options) {
-                const opts = JSON.stringify(options, null, 2).slice(1, -1);
-                messageForSnapshot.push('#### ⚙️ Options', indentCode(removeTrailingBlankLines(opts), 2));
-            }
-            for (const [index, message] of messages.entries()) {
-                if (message.fatal) {
-                    throw new Error(message.message);
-                }
-                const codeWithMessage = printCode(code, message, 1);
-                messageForSnapshot.push(printWithIndex('#### ❌ Error', index, messages.length), indentCode(codeWithMessage));
-                // Don't print suggestions in snapshots for too big codes
-                if (message.suggestions && (code.match(/\n/g) || '').length < 1000) {
-                    for (const [i, suggestion] of message.suggestions.entries()) {
-                        const title = printWithIndex('#### 💡 Suggestion', i, message.suggestions.length, suggestion.desc);
-                        const output = applyFix(code, suggestion.fix);
-                        const codeFrame = printCode(output, { line: 0, column: 0 });
-                        messageForSnapshot.push(title, indentCode(codeFrame, 2));
-                    }
-                }
-            }
-            if (rule.meta.fixable) {
-                const { fixed, output } = linter.verifyAndFix(code, verifyConfig, filename);
-                if (fixed) {
-                    messageForSnapshot.push('#### 🔧 Autofix output', indentCode(printCode(output)));
-                }
-            }
-            it(name || `Invalid #${idx + 1}`, () => {
-                expect(messageForSnapshot.join('\n\n')).toMatchSnapshot();
-            });
+class GraphQLRuleTester extends RuleTester {
+  constructor(parserOptions = {}) {
+    const config = {
+      parser: require.resolve("@graphql-eslint/eslint-plugin"),
+      parserOptions: {
+        ...parserOptions,
+        skipGraphQLConfig: true
+      }
+    };
+    super(config);
+    this.config = config;
+  }
+  fromMockFile(path) {
+    return readFileSync(resolve(__dirname, `../tests/mocks/${path}`), "utf-8");
+  }
+  runGraphQLTests(ruleId, rule, tests) {
+    super.run(ruleId, rule, tests);
+    const linter = new Linter();
+    linter.defineRule(ruleId, rule);
+    const hasOnlyTest = [...tests.valid, ...tests.invalid].some(
+      (t) => typeof t !== "string" && t.only
+    );
+    for (const [idx, testCase] of tests.invalid.entries()) {
+      const { only, filename, options, name } = testCase;
+      if (hasOnlyTest && !only) {
+        continue;
+      }
+      const code = removeTrailingBlankLines(testCase.code);
+      const verifyConfig = getVerifyConfig(ruleId, this.config, testCase);
+      defineParser(linter, verifyConfig.parser);
+      const messages = linter.verify(code, verifyConfig, filename);
+      if (messages.length === 0) {
+        throw new Error("Invalid case should have at least one error.");
+      }
+      const codeFrame = indentCode(printCode(code, { line: 0, column: 0 }));
+      const messageForSnapshot = ["#### \u2328\uFE0F Code", codeFrame];
+      if (options) {
+        const opts = JSON.stringify(options, null, 2).slice(1, -1);
+        messageForSnapshot.push("#### \u2699\uFE0F Options", indentCode(removeTrailingBlankLines(opts), 2));
+      }
+      for (const [index, message] of messages.entries()) {
+        if (message.fatal) {
+          throw new Error(message.message);
+        }
+        const codeWithMessage = printCode(code, message, 1);
+        messageForSnapshot.push(
+          printWithIndex("#### \u274C Error", index, messages.length),
+          indentCode(codeWithMessage)
+        );
+        if (message.suggestions && (code.match(/\n/g) || "").length < 1e3) {
+          for (const [i, suggestion] of message.suggestions.entries()) {
+            const title = printWithIndex(
+              "#### \u{1F4A1} Suggestion",
+              i,
+              message.suggestions.length,
+              suggestion.desc
+            );
+            const output = applyFix(code, suggestion.fix);
+            const codeFrame2 = printCode(output, { line: 0, column: 0 });
+            messageForSnapshot.push(title, indentCode(codeFrame2, 2));
+          }
         }
+      }
+      if (rule.meta.fixable) {
+        const { fixed, output } = linter.verifyAndFix(code, verifyConfig, filename);
+        if (fixed) {
+          messageForSnapshot.push("#### \u{1F527} Autofix output", indentCode(printCode(output)));
+        }
+      }
+      it(name || `Invalid #${idx + 1}`, () => {
+        expect(messageForSnapshot.join("\n\n")).toMatchSnapshot();
+      });
     }
+  }
 }
 function removeTrailingBlankLines(text) {
-    return text.replace(/^\s*\n/, '').trimEnd();
+  return text.replace(/^\s*\n/, "").trimEnd();
 }
 function printWithIndex(title, index, total, description) {
-    if (total > 1) {
-        title += ` ${index + 1}/${total}`;
-    }
-    if (description) {
-        title += `: ${description}`;
-    }
-    return title;
+  if (total > 1) {
+    title += ` ${index + 1}/${total}`;
+  }
+  if (description) {
+    title += `: ${description}`;
+  }
+  return title;
 }
 function getVerifyConfig(ruleId, testerConfig, testCase) {
-    const { parser = testerConfig.parser, parserOptions, options } = testCase;
-    return {
-        ...testerConfig,
-        parser,
-        parserOptions: {
-            ...testerConfig.parserOptions,
-            ...parserOptions,
-        },
-        rules: {
-            [ruleId]: Array.isArray(options) ? ['error', ...options] : 'error',
-        },
-    };
+  const { parser = testerConfig.parser, parserOptions, options } = testCase;
+  return {
+    ...testerConfig,
+    parser,
+    parserOptions: {
+      ...testerConfig.parserOptions,
+      ...parserOptions
+    },
+    rules: {
+      [ruleId]: Array.isArray(options) ? ["error", ...options] : "error"
+    }
+  };
 }
-const parsers = new WeakMap();
+const parsers = /* @__PURE__ */ new WeakMap();
 function defineParser(linter, parser) {
-    if (!parser) {
-        return;
-    }
-    if (!parsers.has(linter)) {
-        parsers.set(linter, new Set());
-    }
-    const defined = parsers.get(linter);
-    if (!defined.has(parser)) {
-        defined.add(parser);
-        // eslint-disable-next-line @typescript-eslint/no-var-requires
-        linter.defineParser(parser, require(parser));
-    }
+  if (!parser) {
+    return;
+  }
+  if (!parsers.has(linter)) {
+    parsers.set(linter, /* @__PURE__ */ new Set());
+  }
+  const defined = parsers.get(linter);
+  if (!defined.has(parser)) {
+    defined.add(parser);
+    linter.defineParser(parser, require(parser));
+  }
 }
 function printCode(code, result = {}, linesOffset = Number.POSITIVE_INFINITY) {
-    const { line, column, endLine, endColumn, message } = result;
-    const location = {};
-    if (typeof line === 'number' && typeof column === 'number') {
-        location.start = {
-            line,
-            column,
-        };
-    }
-    if (typeof endLine === 'number' && typeof endColumn === 'number') {
-        location.end = {
-            line: endLine,
-            column: endColumn,
-        };
-    }
-    return codeFrameColumns(code, location, {
-        linesAbove: linesOffset,
-        linesBelow: linesOffset,
-        message,
-    });
+  const { line, column, endLine, endColumn, message } = result;
+  const location = {};
+  if (typeof line === "number" && typeof column === "number") {
+    location.start = {
+      line,
+      column
+    };
+  }
+  if (typeof endLine === "number" && typeof endColumn === "number") {
+    location.end = {
+      line: endLine,
+      column: endColumn
+    };
+  }
+  return codeFrameColumns(code, location, {
+    linesAbove: linesOffset,
+    linesBelow: linesOffset,
+    message
+  });
 }
+export {
+  GraphQLRuleTester
+};

package/esm/types-2e1afd7c.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.mjs';
+
+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 };