graphql 15.3.0 → 15.5.1

package/jsutils/naturalCompare.js.flow

@@ -0,0 +1,59 @@
+// @flow strict
+/**
+ * Returns a number indicating whether a reference string comes before, or after,
+ * or is the same as the given string in natural sort order.
+ *
+ * See: https://en.wikipedia.org/wiki/Natural_sort_order
+ *
+ */
+export default function naturalCompare(aStr: string, bStr: string): number {
+  let aIdx = 0;
+  let bIdx = 0;
+
+  while (aIdx < aStr.length && bIdx < bStr.length) {
+    let aChar = aStr.charCodeAt(aIdx);
+    let bChar = bStr.charCodeAt(bIdx);
+
+    if (isDigit(aChar) && isDigit(bChar)) {
+      let aNum = 0;
+      do {
+        ++aIdx;
+        aNum = aNum * 10 + aChar - DIGIT_0;
+        aChar = aStr.charCodeAt(aIdx);
+      } while (isDigit(aChar) && aNum > 0);
+
+      let bNum = 0;
+      do {
+        ++bIdx;
+        bNum = bNum * 10 + bChar - DIGIT_0;
+        bChar = bStr.charCodeAt(bIdx);
+      } while (isDigit(bChar) && bNum > 0);
+
+      if (aNum < bNum) {
+        return -1;
+      }
+
+      if (aNum > bNum) {
+        return 1;
+      }
+    } else {
+      if (aChar < bChar) {
+        return -1;
+      }
+      if (aChar > bChar) {
+        return 1;
+      }
+      ++aIdx;
+      ++bIdx;
+    }
+  }
+
+  return aStr.length - bStr.length;
+}
+
+const DIGIT_0 = 48;
+const DIGIT_9 = 57;
+
+function isDigit(code: number): boolean {
+  return !isNaN(code) && DIGIT_0 <= code && code <= DIGIT_9;
+}

package/jsutils/naturalCompare.mjs

@@ -0,0 +1,61 @@
+/**
+ * Returns a number indicating whether a reference string comes before, or after,
+ * or is the same as the given string in natural sort order.
+ *
+ * See: https://en.wikipedia.org/wiki/Natural_sort_order
+ *
+ */
+export default function naturalCompare(aStr, bStr) {
+  var aIdx = 0;
+  var bIdx = 0;
+
+  while (aIdx < aStr.length && bIdx < bStr.length) {
+    var aChar = aStr.charCodeAt(aIdx);
+    var bChar = bStr.charCodeAt(bIdx);
+
+    if (isDigit(aChar) && isDigit(bChar)) {
+      var aNum = 0;
+
+      do {
+        ++aIdx;
+        aNum = aNum * 10 + aChar - DIGIT_0;
+        aChar = aStr.charCodeAt(aIdx);
+      } while (isDigit(aChar) && aNum > 0);
+
+      var bNum = 0;
+
+      do {
+        ++bIdx;
+        bNum = bNum * 10 + bChar - DIGIT_0;
+        bChar = bStr.charCodeAt(bIdx);
+      } while (isDigit(bChar) && bNum > 0);
+
+      if (aNum < bNum) {
+        return -1;
+      }
+
+      if (aNum > bNum) {
+        return 1;
+      }
+    } else {
+      if (aChar < bChar) {
+        return -1;
+      }
+
+      if (aChar > bChar) {
+        return 1;
+      }
+
+      ++aIdx;
+      ++bIdx;
+    }
+  }
+
+  return aStr.length - bStr.length;
+}
+var DIGIT_0 = 48;
+var DIGIT_9 = 57;
+
+function isDigit(code) {
+  return !isNaN(code) && DIGIT_0 <= code && code <= DIGIT_9;
+}

package/jsutils/nodejsCustomInspectSymbol.js.flow

@@ -1,5 +1,4 @@
 // @flow strict
-
 // istanbul ignore next (See: 'https://github.com/graphql/graphql-js/issues/2317')
 const nodejsCustomInspectSymbol =
   typeof Symbol === 'function' && typeof Symbol.for === 'function'

package/jsutils/printPathArray.js.flow

@@ -1,5 +1,4 @@
 // @flow strict
-
 /**
  * Build a string describing the path.
  */

package/jsutils/promiseForObject.js.flow

@@ -1,5 +1,4 @@
 // @flow strict
-
 import type { ObjMap } from './ObjMap';
 
 /**

package/jsutils/promiseReduce.js

@@ -5,7 +5,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = promiseReduce;
 
-var _isPromise = _interopRequireDefault(require("./isPromise"));
+var _isPromise = _interopRequireDefault(require("./isPromise.js"));
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 

package/jsutils/promiseReduce.js.flow

@@ -1,5 +1,4 @@
 // @flow strict
-
 import type { PromiseOrValue } from './PromiseOrValue';
 
 import isPromise from './isPromise';

package/jsutils/safeArrayFrom.js

@@ -0,0 +1,73 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = safeArrayFrom;
+
+var _symbols = require("../polyfills/symbols.js");
+
+function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+/**
+ * Safer version of `Array.from` that return `null` if value isn't convertible to array.
+ * Also protects against Array-like objects without items.
+ *
+ * @example
+ *
+ * safeArrayFrom([ 1, 2, 3 ]) // [1, 2, 3]
+ * safeArrayFrom('ABC') // null
+ * safeArrayFrom({ length: 1 }) // null
+ * safeArrayFrom({ length: 1, 0: 'Alpha' }) // ['Alpha']
+ * safeArrayFrom({ key: 'value' }) // null
+ * safeArrayFrom(new Map()) // []
+ *
+ */
+function safeArrayFrom(collection) {
+  var mapFn = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : function (item) {
+    return item;
+  };
+
+  if (collection == null || _typeof(collection) !== 'object') {
+    return null;
+  }
+
+  if (Array.isArray(collection)) {
+    return collection.map(mapFn);
+  } // Is Iterable?
+
+
+  var iteratorMethod = collection[_symbols.SYMBOL_ITERATOR];
+
+  if (typeof iteratorMethod === 'function') {
+    // $FlowFixMe[incompatible-use]
+    var iterator = iteratorMethod.call(collection);
+    var result = [];
+    var step;
+
+    for (var i = 0; !(step = iterator.next()).done; ++i) {
+      result.push(mapFn(step.value, i));
+    }
+
+    return result;
+  } // Is Array like?
+
+
+  var length = collection.length;
+
+  if (typeof length === 'number' && length >= 0 && length % 1 === 0) {
+    var _result = [];
+
+    for (var _i = 0; _i < length; ++_i) {
+      if (!Object.prototype.hasOwnProperty.call(collection, _i)) {
+        return null;
+      }
+
+      _result.push(mapFn(collection[String(_i)], _i));
+    }
+
+    return _result;
+  }
+
+  return null;
+}

package/jsutils/safeArrayFrom.js.flow

@@ -0,0 +1,59 @@
+// @flow strict
+import { SYMBOL_ITERATOR } from '../polyfills/symbols';
+
+/**
+ * Safer version of `Array.from` that return `null` if value isn't convertible to array.
+ * Also protects against Array-like objects without items.
+ *
+ * @example
+ *
+ * safeArrayFrom([ 1, 2, 3 ]) // [1, 2, 3]
+ * safeArrayFrom('ABC') // null
+ * safeArrayFrom({ length: 1 }) // null
+ * safeArrayFrom({ length: 1, 0: 'Alpha' }) // ['Alpha']
+ * safeArrayFrom({ key: 'value' }) // null
+ * safeArrayFrom(new Map()) // []
+ *
+ */
+export default function safeArrayFrom<T>(
+  collection: mixed,
+  mapFn: (elem: mixed, index: number) => T = (item) => ((item: any): T),
+): Array<T> | null {
+  if (collection == null || typeof collection !== 'object') {
+    return null;
+  }
+
+  if (Array.isArray(collection)) {
+    return collection.map(mapFn);
+  }
+
+  // Is Iterable?
+  const iteratorMethod = collection[SYMBOL_ITERATOR];
+  if (typeof iteratorMethod === 'function') {
+    // $FlowFixMe[incompatible-use]
+    const iterator = iteratorMethod.call(collection);
+    const result = [];
+    let step;
+
+    for (let i = 0; !(step = iterator.next()).done; ++i) {
+      result.push(mapFn(step.value, i));
+    }
+    return result;
+  }
+
+  // Is Array like?
+  const length = collection.length;
+  if (typeof length === 'number' && length >= 0 && length % 1 === 0) {
+    const result = [];
+    for (let i = 0; i < length; ++i) {
+      if (!Object.prototype.hasOwnProperty.call(collection, i)) {
+        return null;
+      }
+      result.push(mapFn(collection[String(i)], i));
+    }
+
+    return result;
+  }
+
+  return null;
+}

package/jsutils/safeArrayFrom.mjs

@@ -0,0 +1,66 @@
+function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+import { SYMBOL_ITERATOR } from "../polyfills/symbols.mjs";
+/**
+ * Safer version of `Array.from` that return `null` if value isn't convertible to array.
+ * Also protects against Array-like objects without items.
+ *
+ * @example
+ *
+ * safeArrayFrom([ 1, 2, 3 ]) // [1, 2, 3]
+ * safeArrayFrom('ABC') // null
+ * safeArrayFrom({ length: 1 }) // null
+ * safeArrayFrom({ length: 1, 0: 'Alpha' }) // ['Alpha']
+ * safeArrayFrom({ key: 'value' }) // null
+ * safeArrayFrom(new Map()) // []
+ *
+ */
+
+export default function safeArrayFrom(collection) {
+  var mapFn = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : function (item) {
+    return item;
+  };
+
+  if (collection == null || _typeof(collection) !== 'object') {
+    return null;
+  }
+
+  if (Array.isArray(collection)) {
+    return collection.map(mapFn);
+  } // Is Iterable?
+
+
+  var iteratorMethod = collection[SYMBOL_ITERATOR];
+
+  if (typeof iteratorMethod === 'function') {
+    // $FlowFixMe[incompatible-use]
+    var iterator = iteratorMethod.call(collection);
+    var result = [];
+    var step;
+
+    for (var i = 0; !(step = iterator.next()).done; ++i) {
+      result.push(mapFn(step.value, i));
+    }
+
+    return result;
+  } // Is Array like?
+
+
+  var length = collection.length;
+
+  if (typeof length === 'number' && length >= 0 && length % 1 === 0) {
+    var _result = [];
+
+    for (var _i = 0; _i < length; ++_i) {
+      if (!Object.prototype.hasOwnProperty.call(collection, _i)) {
+        return null;
+      }
+
+      _result.push(mapFn(collection[String(_i)], _i));
+    }
+
+    return _result;
+  }
+
+  return null;
+}

package/jsutils/suggestionList.js

@@ -5,6 +5,10 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = suggestionList;
 
+var _naturalCompare = _interopRequireDefault(require("./naturalCompare.js"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
 /**
  * Given an invalid input string and a list of valid options, returns a filtered
  * list of valid options sorted based on their similarity with the input.
@@ -25,7 +29,7 @@ function suggestionList(input, options) {
 
   return Object.keys(optionsByDistance).sort(function (a, b) {
     var distanceDiff = optionsByDistance[a] - optionsByDistance[b];
-    return distanceDiff !== 0 ? distanceDiff : a.localeCompare(b);
+    return distanceDiff !== 0 ? distanceDiff : (0, _naturalCompare.default)(a, b);
   });
 }
 /**

package/jsutils/suggestionList.js.flow

@@ -1,4 +1,5 @@
 // @flow strict
+import naturalCompare from './naturalCompare';
 
 /**
  * Given an invalid input string and a list of valid options, returns a filtered
@@ -21,7 +22,7 @@ export default function suggestionList(
 
   return Object.keys(optionsByDistance).sort((a, b) => {
     const distanceDiff = optionsByDistance[a] - optionsByDistance[b];
-    return distanceDiff !== 0 ? distanceDiff : a.localeCompare(b);
+    return distanceDiff !== 0 ? distanceDiff : naturalCompare(a, b);
   });
 }
 
@@ -127,7 +128,7 @@ class LexicalDistance {
   }
 }
 
-function stringToArray(str) {
+function stringToArray(str: string): Array<number> {
   const strLength = str.length;
   const array = new Array(strLength);
   for (let i = 0; i < strLength; ++i) {

package/jsutils/suggestionList.mjs

@@ -1,7 +1,9 @@
+import naturalCompare from "./naturalCompare.mjs";
 /**
  * Given an invalid input string and a list of valid options, returns a filtered
  * list of valid options sorted based on their similarity with the input.
  */
+
 export default function suggestionList(input, options) {
   var optionsByDistance = Object.create(null);
   var lexicalDistance = new LexicalDistance(input);
@@ -18,7 +20,7 @@ export default function suggestionList(input, options) {
 
   return Object.keys(optionsByDistance).sort(function (a, b) {
     var distanceDiff = optionsByDistance[a] - optionsByDistance[b];
-    return distanceDiff !== 0 ? distanceDiff : a.localeCompare(b);
+    return distanceDiff !== 0 ? distanceDiff : naturalCompare(a, b);
   });
 }
 /**

package/jsutils/toObjMap.js

@@ -5,7 +5,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = toObjMap;
 
-var _objectEntries3 = _interopRequireDefault(require("../polyfills/objectEntries"));
+var _objectEntries3 = _interopRequireDefault(require("../polyfills/objectEntries.js"));
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 

package/jsutils/toObjMap.js.flow

@@ -1,5 +1,4 @@
 // @flow strict
-
 import objectEntries from '../polyfills/objectEntries';
 
 import type {

package/language/ast.js

@@ -6,7 +6,7 @@ Object.defineProperty(exports, "__esModule", {
 exports.isNode = isNode;
 exports.Token = exports.Location = void 0;
 
-var _defineInspect = _interopRequireDefault(require("../jsutils/defineInspect"));
+var _defineInspect = _interopRequireDefault(require("../jsutils/defineInspect.js"));
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 

package/language/ast.js.flow

@@ -1,5 +1,4 @@
 // @flow strict
-
 import defineInspect from '../jsutils/defineInspect';
 
 import type { Source } from './source';

package/language/blockString.d.ts

@@ -9,7 +9,7 @@ export function dedentBlockStringValue(rawString: string): string;
 /**
  * @internal
  */
-export function getBlockStringIndentation(lines: ReadonlyArray<string>): number;
+export function getBlockStringIndentation(body: string): number;
 
 /**
  * Print a block string in the indented block form by adding a leading and

package/language/blockString.js

@@ -19,7 +19,7 @@ function dedentBlockStringValue(rawString) {
   // Expand a block string's raw value into independent lines.
   var lines = rawString.split(/\r\n|[\n\r]/g); // Remove common indentation from all lines but first.
 
-  var commonIndent = getBlockStringIndentation(lines);
+  var commonIndent = getBlockStringIndentation(rawString);
 
   if (commonIndent !== 0) {
     for (var i = 1; i < lines.length; i++) {
@@ -28,57 +28,78 @@ function dedentBlockStringValue(rawString) {
   } // Remove leading and trailing blank lines.
 
 
-  while (lines.length > 0 && isBlank(lines[0])) {
-    lines.shift();
+  var startLine = 0;
+
+  while (startLine < lines.length && isBlank(lines[startLine])) {
+    ++startLine;
   }
 
-  while (lines.length > 0 && isBlank(lines[lines.length - 1])) {
-    lines.pop();
+  var endLine = lines.length;
+
+  while (endLine > startLine && isBlank(lines[endLine - 1])) {
+    --endLine;
   } // Return a string of the lines joined with U+000A.
 
 
-  return lines.join('\n');
+  return lines.slice(startLine, endLine).join('\n');
+}
+
+function isBlank(str) {
+  for (var i = 0; i < str.length; ++i) {
+    if (str[i] !== ' ' && str[i] !== '\t') {
+      return false;
+    }
+  }
+
+  return true;
 }
 /**
  * @internal
  */
 
 
-function getBlockStringIndentation(lines) {
-  var commonIndent = null;
+function getBlockStringIndentation(value) {
+  var _commonIndent;
 
-  for (var i = 1; i < lines.length; i++) {
-    var line = lines[i];
-    var indent = leadingWhitespace(line);
+  var isFirstLine = true;
+  var isEmptyLine = true;
+  var indent = 0;
+  var commonIndent = null;
 
-    if (indent === line.length) {
-      continue; // skip empty lines
-    }
+  for (var i = 0; i < value.length; ++i) {
+    switch (value.charCodeAt(i)) {
+      case 13:
+        //  \r
+        if (value.charCodeAt(i + 1) === 10) {
+          ++i; // skip \r\n as one symbol
+        }
+
+      // falls through
+
+      case 10:
+        //  \n
+        isFirstLine = false;
+        isEmptyLine = true;
+        indent = 0;
+        break;
 
-    if (commonIndent === null || indent < commonIndent) {
-      commonIndent = indent;
+      case 9: //   \t
 
-      if (commonIndent === 0) {
+      case 32:
+        //  <space>
+        ++indent;
         break;
-      }
-    }
-  }
-
-  return commonIndent === null ? 0 : commonIndent;
-}
 
-function leadingWhitespace(str) {
-  var i = 0;
+      default:
+        if (isEmptyLine && !isFirstLine && (commonIndent === null || indent < commonIndent)) {
+          commonIndent = indent;
+        }
 
-  while (i < str.length && (str[i] === ' ' || str[i] === '\t')) {
-    i++;
+        isEmptyLine = false;
+    }
   }
 
-  return i;
-}
-
-function isBlank(str) {
-  return leadingWhitespace(str) === str.length;
+  return (_commonIndent = commonIndent) !== null && _commonIndent !== void 0 ? _commonIndent : 0;
 }
 /**
  * Print a block string in the indented block form by adding a leading and