graphql 16.14.0 → 16.14.1

package/validation/rules/KnownTypeNamesRule.js

@@ -17,6 +17,8 @@ var _introspection = require('../../type/introspection.js');
 
 var _scalars = require('../../type/scalars.js');
 
+/** @category Validation Rules */
+
 /**
  * Known type names
  *
@@ -24,6 +26,33 @@ var _scalars = require('../../type/scalars.js');
  * variable definitions and fragment conditions) are defined by the type schema.
  *
  * See https://spec.graphql.org/draft/#sec-Fragment-Spread-Type-Existence
+ * @param context - The validation context used while checking the document.
+ * @returns A visitor that reports validation errors for this rule.
+ * @example
+ * ```ts
+ * import { buildSchema, parse, validate } from 'graphql';
+ * import { KnownTypeNamesRule } from 'graphql/validation';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     name: String
+ *   }
+ * `);
+ *
+ * const invalidDocument = parse(`
+ *   fragment Bad on Missing { name }
+ * `);
+ * const invalidErrors = validate(schema, invalidDocument, [KnownTypeNamesRule]);
+ *
+ * invalidErrors.length; // => 1
+ *
+ * const validDocument = parse(`
+ *   fragment Good on Query { name }
+ * `);
+ * const validErrors = validate(schema, validDocument, [KnownTypeNamesRule]);
+ *
+ * validErrors; // => []
+ * ```
  */
 function KnownTypeNamesRule(context) {
   const schema = context.getSchema();

package/validation/rules/KnownTypeNamesRule.mjs

@@ -1,3 +1,4 @@
+/** @category Validation Rules */
 import { didYouMean } from '../../jsutils/didYouMean.mjs';
 import { suggestionList } from '../../jsutils/suggestionList.mjs';
 import { GraphQLError } from '../../error/GraphQLError.mjs';
@@ -16,6 +17,33 @@ import { specifiedScalarTypes } from '../../type/scalars.mjs';
  * variable definitions and fragment conditions) are defined by the type schema.
  *
  * See https://spec.graphql.org/draft/#sec-Fragment-Spread-Type-Existence
+ * @param context - The validation context used while checking the document.
+ * @returns A visitor that reports validation errors for this rule.
+ * @example
+ * ```ts
+ * import { buildSchema, parse, validate } from 'graphql';
+ * import { KnownTypeNamesRule } from 'graphql/validation';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     name: String
+ *   }
+ * `);
+ *
+ * const invalidDocument = parse(`
+ *   fragment Bad on Missing { name }
+ * `);
+ * const invalidErrors = validate(schema, invalidDocument, [KnownTypeNamesRule]);
+ *
+ * invalidErrors.length; // => 1
+ *
+ * const validDocument = parse(`
+ *   fragment Good on Query { name }
+ * `);
+ * const validErrors = validate(schema, validDocument, [KnownTypeNamesRule]);
+ *
+ * validErrors; // => []
+ * ```
  */
 export function KnownTypeNamesRule(context) {
   const schema = context.getSchema();

package/validation/rules/LoneAnonymousOperationRule.d.ts

@@ -1,3 +1,4 @@
+/** @category Validation Rules */
 import type { ASTVisitor } from '../../language/visitor';
 import type { ASTValidationContext } from '../ValidationContext';
 /**
@@ -7,6 +8,33 @@ import type { ASTValidationContext } from '../ValidationContext';
  * (the query short-hand) that it contains only that one operation definition.
  *
  * See https://spec.graphql.org/draft/#sec-Lone-Anonymous-Operation
+ * @param context - The validation context used while checking the document.
+ * @returns A visitor that reports validation errors for this rule.
+ * @example
+ * ```ts
+ * import { buildSchema, parse, validate } from 'graphql';
+ * import { LoneAnonymousOperationRule } from 'graphql/validation';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     name: String
+ *   }
+ * `);
+ *
+ * const invalidDocument = parse(`
+ *   query { name } query Other { name }
+ * `);
+ * const invalidErrors = validate(schema, invalidDocument, [LoneAnonymousOperationRule]);
+ *
+ * invalidErrors.length; // => 1
+ *
+ * const validDocument = parse(`
+ *   { name }
+ * `);
+ * const validErrors = validate(schema, validDocument, [LoneAnonymousOperationRule]);
+ *
+ * validErrors; // => []
+ * ```
  */
 export declare function LoneAnonymousOperationRule(
   context: ASTValidationContext,

package/validation/rules/LoneAnonymousOperationRule.js

@@ -9,6 +9,8 @@ var _GraphQLError = require('../../error/GraphQLError.js');
 
 var _kinds = require('../../language/kinds.js');
 
+/** @category Validation Rules */
+
 /**
  * Lone anonymous operation
  *
@@ -16,6 +18,33 @@ var _kinds = require('../../language/kinds.js');
  * (the query short-hand) that it contains only that one operation definition.
  *
  * See https://spec.graphql.org/draft/#sec-Lone-Anonymous-Operation
+ * @param context - The validation context used while checking the document.
+ * @returns A visitor that reports validation errors for this rule.
+ * @example
+ * ```ts
+ * import { buildSchema, parse, validate } from 'graphql';
+ * import { LoneAnonymousOperationRule } from 'graphql/validation';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     name: String
+ *   }
+ * `);
+ *
+ * const invalidDocument = parse(`
+ *   query { name } query Other { name }
+ * `);
+ * const invalidErrors = validate(schema, invalidDocument, [LoneAnonymousOperationRule]);
+ *
+ * invalidErrors.length; // => 1
+ *
+ * const validDocument = parse(`
+ *   { name }
+ * `);
+ * const validErrors = validate(schema, validDocument, [LoneAnonymousOperationRule]);
+ *
+ * validErrors; // => []
+ * ```
  */
 function LoneAnonymousOperationRule(context) {
   let operationCount = 0;

package/validation/rules/LoneAnonymousOperationRule.mjs

@@ -1,3 +1,4 @@
+/** @category Validation Rules */
 import { GraphQLError } from '../../error/GraphQLError.mjs';
 import { Kind } from '../../language/kinds.mjs';
 
@@ -8,6 +9,33 @@ import { Kind } from '../../language/kinds.mjs';
  * (the query short-hand) that it contains only that one operation definition.
  *
  * See https://spec.graphql.org/draft/#sec-Lone-Anonymous-Operation
+ * @param context - The validation context used while checking the document.
+ * @returns A visitor that reports validation errors for this rule.
+ * @example
+ * ```ts
+ * import { buildSchema, parse, validate } from 'graphql';
+ * import { LoneAnonymousOperationRule } from 'graphql/validation';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     name: String
+ *   }
+ * `);
+ *
+ * const invalidDocument = parse(`
+ *   query { name } query Other { name }
+ * `);
+ * const invalidErrors = validate(schema, invalidDocument, [LoneAnonymousOperationRule]);
+ *
+ * invalidErrors.length; // => 1
+ *
+ * const validDocument = parse(`
+ *   { name }
+ * `);
+ * const validErrors = validate(schema, validDocument, [LoneAnonymousOperationRule]);
+ *
+ * validErrors; // => []
+ * ```
  */
 export function LoneAnonymousOperationRule(context) {
   let operationCount = 0;

package/validation/rules/LoneSchemaDefinitionRule.d.ts

@@ -1,9 +1,30 @@
+/** @category Validation Rules */
 import type { ASTVisitor } from '../../language/visitor';
 import type { SDLValidationContext } from '../ValidationContext';
 /**
  * Lone Schema definition
  *
  * A GraphQL document is only valid if it contains only one schema definition.
+ * @param context - The validation context used while checking the document.
+ * @returns A visitor that reports validation errors for this rule.
+ * @example
+ * ```ts
+ * import { buildSchema } from 'graphql';
+ * import { LoneSchemaDefinitionRule } from 'graphql/validation';
+ *
+ * const invalidSDL = `
+ *   schema { query: Query } schema { query: Query } type Query { name: String }
+ * `;
+ *
+ * LoneSchemaDefinitionRule.name; // => 'LoneSchemaDefinitionRule'
+ * buildSchema(invalidSDL); // throws an error
+ *
+ * const validSDL = `
+ *   schema { query: Query } type Query { name: String }
+ * `;
+ *
+ * buildSchema(validSDL); // does not throw
+ * ```
  */
 export declare function LoneSchemaDefinitionRule(
   context: SDLValidationContext,

package/validation/rules/LoneSchemaDefinitionRule.js

@@ -7,10 +7,32 @@ exports.LoneSchemaDefinitionRule = LoneSchemaDefinitionRule;
 
 var _GraphQLError = require('../../error/GraphQLError.js');
 
+/** @category Validation Rules */
+
 /**
  * Lone Schema definition
  *
  * A GraphQL document is only valid if it contains only one schema definition.
+ * @param context - The validation context used while checking the document.
+ * @returns A visitor that reports validation errors for this rule.
+ * @example
+ * ```ts
+ * import { buildSchema } from 'graphql';
+ * import { LoneSchemaDefinitionRule } from 'graphql/validation';
+ *
+ * const invalidSDL = `
+ *   schema { query: Query } schema { query: Query } type Query { name: String }
+ * `;
+ *
+ * LoneSchemaDefinitionRule.name; // => 'LoneSchemaDefinitionRule'
+ * buildSchema(invalidSDL); // throws an error
+ *
+ * const validSDL = `
+ *   schema { query: Query } type Query { name: String }
+ * `;
+ *
+ * buildSchema(validSDL); // does not throw
+ * ```
  */
 function LoneSchemaDefinitionRule(context) {
   var _ref, _ref2, _oldSchema$astNode;

package/validation/rules/LoneSchemaDefinitionRule.mjs

@@ -1,9 +1,30 @@
+/** @category Validation Rules */
 import { GraphQLError } from '../../error/GraphQLError.mjs';
 
 /**
  * Lone Schema definition
  *
  * A GraphQL document is only valid if it contains only one schema definition.
+ * @param context - The validation context used while checking the document.
+ * @returns A visitor that reports validation errors for this rule.
+ * @example
+ * ```ts
+ * import { buildSchema } from 'graphql';
+ * import { LoneSchemaDefinitionRule } from 'graphql/validation';
+ *
+ * const invalidSDL = `
+ *   schema { query: Query } schema { query: Query } type Query { name: String }
+ * `;
+ *
+ * LoneSchemaDefinitionRule.name; // => 'LoneSchemaDefinitionRule'
+ * buildSchema(invalidSDL); // throws an error
+ *
+ * const validSDL = `
+ *   schema { query: Query } type Query { name: String }
+ * `;
+ *
+ * buildSchema(validSDL); // does not throw
+ * ```
  */
 export function LoneSchemaDefinitionRule(context) {
   var _ref, _ref2, _oldSchema$astNode;

package/validation/rules/MaxIntrospectionDepthRule.d.ts

@@ -1,5 +1,36 @@
+/** @category Validation Rules */
 import type { ASTVisitor } from '../../language/visitor';
 import type { ASTValidationContext } from '../ValidationContext';
+/**
+ * Implements the max introspection depth validation rule.
+ * @param context - The validation context used while checking the document.
+ * @returns A visitor that reports validation errors for this rule.
+ * @example
+ * ```ts
+ * import { buildSchema, parse, validate } from 'graphql';
+ * import { MaxIntrospectionDepthRule } from 'graphql/validation';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     name: String
+ *   }
+ * `);
+ *
+ * const invalidDocument = parse(`
+ *   { __schema { types { fields { type { fields { type { fields { name } } } } } } } }
+ * `);
+ * const invalidErrors = validate(schema, invalidDocument, [MaxIntrospectionDepthRule]);
+ *
+ * invalidErrors.length; // => 1
+ *
+ * const validDocument = parse(`
+ *   { __schema { queryType { name } } }
+ * `);
+ * const validErrors = validate(schema, validDocument, [MaxIntrospectionDepthRule]);
+ *
+ * validErrors; // => []
+ * ```
+ */
 export declare function MaxIntrospectionDepthRule(
   context: ASTValidationContext,
 ): ASTVisitor;

package/validation/rules/MaxIntrospectionDepthRule.js

@@ -9,12 +9,45 @@ var _GraphQLError = require('../../error/GraphQLError.js');
 
 var _kinds = require('../../language/kinds.js');
 
+/** @category Validation Rules */
 const MAX_LISTS_DEPTH = 3;
+/**
+ * Implements the max introspection depth validation rule.
+ * @param context - The validation context used while checking the document.
+ * @returns A visitor that reports validation errors for this rule.
+ * @example
+ * ```ts
+ * import { buildSchema, parse, validate } from 'graphql';
+ * import { MaxIntrospectionDepthRule } from 'graphql/validation';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     name: String
+ *   }
+ * `);
+ *
+ * const invalidDocument = parse(`
+ *   { __schema { types { fields { type { fields { type { fields { name } } } } } } } }
+ * `);
+ * const invalidErrors = validate(schema, invalidDocument, [MaxIntrospectionDepthRule]);
+ *
+ * invalidErrors.length; // => 1
+ *
+ * const validDocument = parse(`
+ *   { __schema { queryType { name } } }
+ * `);
+ * const validErrors = validate(schema, validDocument, [MaxIntrospectionDepthRule]);
+ *
+ * validErrors; // => []
+ * ```
+ */
 
 function MaxIntrospectionDepthRule(context) {
   /**
    * Counts the depth of list fields in "__Type" recursively and
    * returns `true` if the limit has been reached.
+   *
+   * @internal
    */
   function checkDepth(node, visitedFragments = Object.create(null), depth = 0) {
     if (node.kind === _kinds.Kind.FRAGMENT_SPREAD) {

package/validation/rules/MaxIntrospectionDepthRule.mjs

@@ -1,10 +1,44 @@
+/** @category Validation Rules */
 import { GraphQLError } from '../../error/GraphQLError.mjs';
 import { Kind } from '../../language/kinds.mjs';
 const MAX_LISTS_DEPTH = 3;
+/**
+ * Implements the max introspection depth validation rule.
+ * @param context - The validation context used while checking the document.
+ * @returns A visitor that reports validation errors for this rule.
+ * @example
+ * ```ts
+ * import { buildSchema, parse, validate } from 'graphql';
+ * import { MaxIntrospectionDepthRule } from 'graphql/validation';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     name: String
+ *   }
+ * `);
+ *
+ * const invalidDocument = parse(`
+ *   { __schema { types { fields { type { fields { type { fields { name } } } } } } } }
+ * `);
+ * const invalidErrors = validate(schema, invalidDocument, [MaxIntrospectionDepthRule]);
+ *
+ * invalidErrors.length; // => 1
+ *
+ * const validDocument = parse(`
+ *   { __schema { queryType { name } } }
+ * `);
+ * const validErrors = validate(schema, validDocument, [MaxIntrospectionDepthRule]);
+ *
+ * validErrors; // => []
+ * ```
+ */
+
 export function MaxIntrospectionDepthRule(context) {
   /**
    * Counts the depth of list fields in "__Type" recursively and
    * returns `true` if the limit has been reached.
+   *
+   * @internal
    */
   function checkDepth(node, visitedFragments = Object.create(null), depth = 0) {
     if (node.kind === Kind.FRAGMENT_SPREAD) {

package/validation/rules/NoFragmentCyclesRule.d.ts

@@ -1,3 +1,4 @@
+/** @category Validation Rules */
 import type { ASTVisitor } from '../../language/visitor';
 import type { ASTValidationContext } from '../ValidationContext';
 /**
@@ -7,6 +8,33 @@ import type { ASTValidationContext } from '../ValidationContext';
  * Otherwise an operation could infinitely spread or infinitely execute on cycles in the underlying data.
  *
  * See https://spec.graphql.org/draft/#sec-Fragment-spreads-must-not-form-cycles
+ * @param context - The validation context used while checking the document.
+ * @returns A visitor that reports validation errors for this rule.
+ * @example
+ * ```ts
+ * import { buildSchema, parse, validate } from 'graphql';
+ * import { NoFragmentCyclesRule } from 'graphql/validation';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     name: String
+ *   }
+ * `);
+ *
+ * const invalidDocument = parse(`
+ *   fragment A on Query { ...B } fragment B on Query { ...A } query { ...A }
+ * `);
+ * const invalidErrors = validate(schema, invalidDocument, [NoFragmentCyclesRule]);
+ *
+ * invalidErrors.length; // => 1
+ *
+ * const validDocument = parse(`
+ *   fragment A on Query { name } query { ...A }
+ * `);
+ * const validErrors = validate(schema, validDocument, [NoFragmentCyclesRule]);
+ *
+ * validErrors; // => []
+ * ```
  */
 export declare function NoFragmentCyclesRule(
   context: ASTValidationContext,

package/validation/rules/NoFragmentCyclesRule.js

@@ -7,6 +7,8 @@ exports.NoFragmentCyclesRule = NoFragmentCyclesRule;
 
 var _GraphQLError = require('../../error/GraphQLError.js');
 
+/** @category Validation Rules */
+
 /**
  * No fragment cycles
  *
@@ -14,6 +16,33 @@ var _GraphQLError = require('../../error/GraphQLError.js');
  * Otherwise an operation could infinitely spread or infinitely execute on cycles in the underlying data.
  *
  * See https://spec.graphql.org/draft/#sec-Fragment-spreads-must-not-form-cycles
+ * @param context - The validation context used while checking the document.
+ * @returns A visitor that reports validation errors for this rule.
+ * @example
+ * ```ts
+ * import { buildSchema, parse, validate } from 'graphql';
+ * import { NoFragmentCyclesRule } from 'graphql/validation';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     name: String
+ *   }
+ * `);
+ *
+ * const invalidDocument = parse(`
+ *   fragment A on Query { ...B } fragment B on Query { ...A } query { ...A }
+ * `);
+ * const invalidErrors = validate(schema, invalidDocument, [NoFragmentCyclesRule]);
+ *
+ * invalidErrors.length; // => 1
+ *
+ * const validDocument = parse(`
+ *   fragment A on Query { name } query { ...A }
+ * `);
+ * const validErrors = validate(schema, validDocument, [NoFragmentCyclesRule]);
+ *
+ * validErrors; // => []
+ * ```
  */
 function NoFragmentCyclesRule(context) {
   // Tracks already visited fragments to maintain O(N) and to ensure that cycles

package/validation/rules/NoFragmentCyclesRule.mjs

@@ -1,3 +1,4 @@
+/** @category Validation Rules */
 import { GraphQLError } from '../../error/GraphQLError.mjs';
 
 /**
@@ -7,6 +8,33 @@ import { GraphQLError } from '../../error/GraphQLError.mjs';
  * Otherwise an operation could infinitely spread or infinitely execute on cycles in the underlying data.
  *
  * See https://spec.graphql.org/draft/#sec-Fragment-spreads-must-not-form-cycles
+ * @param context - The validation context used while checking the document.
+ * @returns A visitor that reports validation errors for this rule.
+ * @example
+ * ```ts
+ * import { buildSchema, parse, validate } from 'graphql';
+ * import { NoFragmentCyclesRule } from 'graphql/validation';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     name: String
+ *   }
+ * `);
+ *
+ * const invalidDocument = parse(`
+ *   fragment A on Query { ...B } fragment B on Query { ...A } query { ...A }
+ * `);
+ * const invalidErrors = validate(schema, invalidDocument, [NoFragmentCyclesRule]);
+ *
+ * invalidErrors.length; // => 1
+ *
+ * const validDocument = parse(`
+ *   fragment A on Query { name } query { ...A }
+ * `);
+ * const validErrors = validate(schema, validDocument, [NoFragmentCyclesRule]);
+ *
+ * validErrors; // => []
+ * ```
  */
 export function NoFragmentCyclesRule(context) {
   // Tracks already visited fragments to maintain O(N) and to ensure that cycles

package/validation/rules/NoUndefinedVariablesRule.d.ts

@@ -1,3 +1,4 @@
+/** @category Validation Rules */
 import type { ASTVisitor } from '../../language/visitor';
 import type { ValidationContext } from '../ValidationContext';
 /**
@@ -7,6 +8,33 @@ import type { ValidationContext } from '../ValidationContext';
  * and via fragment spreads, are defined by that operation.
  *
  * See https://spec.graphql.org/draft/#sec-All-Variable-Uses-Defined
+ * @param context - The validation context used while checking the document.
+ * @returns A visitor that reports validation errors for this rule.
+ * @example
+ * ```ts
+ * import { buildSchema, parse, validate } from 'graphql';
+ * import { NoUndefinedVariablesRule } from 'graphql/validation';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     field(arg: ID): String
+ *   }
+ * `);
+ *
+ * const invalidDocument = parse(`
+ *   query ($id: ID) { field(arg: $missing) }
+ * `);
+ * const invalidErrors = validate(schema, invalidDocument, [NoUndefinedVariablesRule]);
+ *
+ * invalidErrors.length; // => 1
+ *
+ * const validDocument = parse(`
+ *   query ($id: ID) { field(arg: $id) }
+ * `);
+ * const validErrors = validate(schema, validDocument, [NoUndefinedVariablesRule]);
+ *
+ * validErrors; // => []
+ * ```
  */
 export declare function NoUndefinedVariablesRule(
   context: ValidationContext,

package/validation/rules/NoUndefinedVariablesRule.js

@@ -7,6 +7,8 @@ exports.NoUndefinedVariablesRule = NoUndefinedVariablesRule;
 
 var _GraphQLError = require('../../error/GraphQLError.js');
 
+/** @category Validation Rules */
+
 /**
  * No undefined variables
  *
@@ -14,6 +16,33 @@ var _GraphQLError = require('../../error/GraphQLError.js');
  * and via fragment spreads, are defined by that operation.
  *
  * See https://spec.graphql.org/draft/#sec-All-Variable-Uses-Defined
+ * @param context - The validation context used while checking the document.
+ * @returns A visitor that reports validation errors for this rule.
+ * @example
+ * ```ts
+ * import { buildSchema, parse, validate } from 'graphql';
+ * import { NoUndefinedVariablesRule } from 'graphql/validation';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     field(arg: ID): String
+ *   }
+ * `);
+ *
+ * const invalidDocument = parse(`
+ *   query ($id: ID) { field(arg: $missing) }
+ * `);
+ * const invalidErrors = validate(schema, invalidDocument, [NoUndefinedVariablesRule]);
+ *
+ * invalidErrors.length; // => 1
+ *
+ * const validDocument = parse(`
+ *   query ($id: ID) { field(arg: $id) }
+ * `);
+ * const validErrors = validate(schema, validDocument, [NoUndefinedVariablesRule]);
+ *
+ * validErrors; // => []
+ * ```
  */
 function NoUndefinedVariablesRule(context) {
   let variableNameDefined = Object.create(null);

package/validation/rules/NoUndefinedVariablesRule.mjs

@@ -1,3 +1,4 @@
+/** @category Validation Rules */
 import { GraphQLError } from '../../error/GraphQLError.mjs';
 
 /**
@@ -7,6 +8,33 @@ import { GraphQLError } from '../../error/GraphQLError.mjs';
  * and via fragment spreads, are defined by that operation.
  *
  * See https://spec.graphql.org/draft/#sec-All-Variable-Uses-Defined
+ * @param context - The validation context used while checking the document.
+ * @returns A visitor that reports validation errors for this rule.
+ * @example
+ * ```ts
+ * import { buildSchema, parse, validate } from 'graphql';
+ * import { NoUndefinedVariablesRule } from 'graphql/validation';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     field(arg: ID): String
+ *   }
+ * `);
+ *
+ * const invalidDocument = parse(`
+ *   query ($id: ID) { field(arg: $missing) }
+ * `);
+ * const invalidErrors = validate(schema, invalidDocument, [NoUndefinedVariablesRule]);
+ *
+ * invalidErrors.length; // => 1
+ *
+ * const validDocument = parse(`
+ *   query ($id: ID) { field(arg: $id) }
+ * `);
+ * const validErrors = validate(schema, validDocument, [NoUndefinedVariablesRule]);
+ *
+ * validErrors; // => []
+ * ```
  */
 export function NoUndefinedVariablesRule(context) {
   let variableNameDefined = Object.create(null);