graphql 15.4.0 → 15.5.0

package/README.md

@@ -115,6 +115,16 @@ directly on this branch:
 npm install graphql@git://github.com/graphql/graphql-js.git#npm
 ```
 
+### Experimental features
+
+Each release of GraphQL.js will be accompanied by an experimental release containing support for the `@defer` and `@stream` directive proposal. We are hoping to get community feedback on these releases before the proposal is accepted into the GraphQL specification. You can use this experimental release of GraphQL.js by adding the following to your project's `package.json` file.
+
+```
+"graphql": "experimental-stream-defer"
+```
+
+Community feedback on this experimental release is much appreciated and can be provided on the [issue created for this purpose](https://github.com/graphql/graphql-js/issues/2848).
+
 ### Using in a Browser
 
 GraphQL.js is a general-purpose library and can be used both in a Node server

package/error/GraphQLError.js

@@ -1,5 +1,7 @@
 "use strict";
 
+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); }
+
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
@@ -16,8 +18,6 @@ var _printLocation = require("../language/printLocation.js");
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-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); }
-
 function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 
 function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
@@ -219,7 +219,7 @@ var GraphQLError = /*#__PURE__*/function (_Error) {
       }
     }); // Include (non-enumerable) stack trace.
 
-    if (originalError === null || originalError === void 0 ? void 0 : originalError.stack) {
+    if (originalError !== null && originalError !== void 0 && originalError.stack) {
       Object.defineProperty(_assertThisInitialized(_this), 'stack', {
         value: originalError.stack,
         writable: true,

package/error/GraphQLError.js.flow

@@ -84,7 +84,7 @@ export class GraphQLError extends Error {
     path?: ?$ReadOnlyArray<string | number>,
     originalError?: ?(Error & { +extensions?: mixed, ... }),
     extensions?: ?{ [key: string]: mixed, ... },
-  ): void {
+  ) {
     super(message);
 
     // Compute list of blame nodes.

package/error/GraphQLError.mjs

@@ -208,7 +208,7 @@ export var GraphQLError = /*#__PURE__*/function (_Error) {
       }
     }); // Include (non-enumerable) stack trace.
 
-    if (originalError === null || originalError === void 0 ? void 0 : originalError.stack) {
+    if (originalError !== null && originalError !== void 0 && originalError.stack) {
       Object.defineProperty(_assertThisInitialized(_this), 'stack', {
         value: originalError.stack,
         writable: true,

package/execution/execute.js

@@ -12,8 +12,6 @@ exports.buildResolveInfo = buildResolveInfo;
 exports.getFieldDef = getFieldDef;
 exports.defaultFieldResolver = exports.defaultTypeResolver = void 0;
 
-var _arrayFrom = _interopRequireDefault(require("../polyfills/arrayFrom.js"));
-
 var _inspect = _interopRequireDefault(require("../jsutils/inspect.js"));
 
 var _memoize = _interopRequireDefault(require("../jsutils/memoize3.js"));
@@ -26,7 +24,7 @@ var _isPromise = _interopRequireDefault(require("../jsutils/isPromise.js"));
 
 var _isObjectLike = _interopRequireDefault(require("../jsutils/isObjectLike.js"));
 
-var _isCollection = _interopRequireDefault(require("../jsutils/isCollection.js"));
+var _safeArrayFrom = _interopRequireDefault(require("../jsutils/safeArrayFrom.js"));
 
 var _promiseReduce = _interopRequireDefault(require("../jsutils/promiseReduce.js"));
 
@@ -602,15 +600,11 @@ function completeValue(exeContext, returnType, fieldNodes, info, path, result) {
 
 
 function completeListValue(exeContext, returnType, fieldNodes, info, path, result) {
-  if (!(0, _isCollection.default)(result)) {
-    throw new _GraphQLError.GraphQLError("Expected Iterable, but did not find one for field \"".concat(info.parentType.name, ".").concat(info.fieldName, "\"."));
-  } // This is specified as a simple map, however we're optimizing the path
+  // This is specified as a simple map, however we're optimizing the path
   // where the list contains no Promises by avoiding creating another Promise.
-
-
   var itemType = returnType.ofType;
   var containsPromise = false;
-  var completedResults = (0, _arrayFrom.default)(result, function (item, index) {
+  var completedResults = (0, _safeArrayFrom.default)(result, function (item, index) {
     // No need to modify the info object containing the path,
     // since from here on it is not ever accessed by resolver functions.
     var itemPath = (0, _Path.addPath)(path, index, undefined);
@@ -642,6 +636,11 @@ function completeListValue(exeContext, returnType, fieldNodes, info, path, resul
       return handleFieldError(error, itemType, exeContext);
     }
   });
+
+  if (completedResults == null) {
+    throw new _GraphQLError.GraphQLError("Expected Iterable, but did not find one for field \"".concat(info.parentType.name, ".").concat(info.fieldName, "\"."));
+  }
+
   return containsPromise ? Promise.all(completedResults) : completedResults;
 }
 /**

package/execution/execute.js.flow

@@ -1,6 +1,4 @@
 // @flow strict
-import arrayFrom from '../polyfills/arrayFrom';
-
 import type { Path } from '../jsutils/Path';
 import type { ObjMap } from '../jsutils/ObjMap';
 import type { PromiseOrValue } from '../jsutils/PromiseOrValue';
@@ -10,7 +8,7 @@ import invariant from '../jsutils/invariant';
 import devAssert from '../jsutils/devAssert';
 import isPromise from '../jsutils/isPromise';
 import isObjectLike from '../jsutils/isObjectLike';
-import isCollection from '../jsutils/isCollection';
+import safeArrayFrom from '../jsutils/safeArrayFrom';
 import promiseReduce from '../jsutils/promiseReduce';
 import promiseForObject from '../jsutils/promiseForObject';
 import { addPath, pathToArray } from '../jsutils/Path';
@@ -868,17 +866,11 @@ function completeListValue(
   path: Path,
   result: mixed,
 ): PromiseOrValue<$ReadOnlyArray<mixed>> {
-  if (!isCollection(result)) {
-    throw new GraphQLError(
-      `Expected Iterable, but did not find one for field "${info.parentType.name}.${info.fieldName}".`,
-    );
-  }
-
   // This is specified as a simple map, however we're optimizing the path
   // where the list contains no Promises by avoiding creating another Promise.
   const itemType = returnType.ofType;
   let containsPromise = false;
-  const completedResults = arrayFrom(result, (item, index) => {
+  const completedResults = safeArrayFrom(result, (item, index) => {
     // No need to modify the info object containing the path,
     // since from here on it is not ever accessed by resolver functions.
     const itemPath = addPath(path, index, undefined);
@@ -926,6 +918,12 @@ function completeListValue(
     }
   });
 
+  if (completedResults == null) {
+    throw new GraphQLError(
+      `Expected Iterable, but did not find one for field "${info.parentType.name}.${info.fieldName}".`,
+    );
+  }
+
   return containsPromise ? Promise.all(completedResults) : completedResults;
 }
 

package/execution/execute.mjs

@@ -1,11 +1,10 @@
-import arrayFrom from "../polyfills/arrayFrom.mjs";
 import inspect from "../jsutils/inspect.mjs";
 import memoize3 from "../jsutils/memoize3.mjs";
 import invariant from "../jsutils/invariant.mjs";
 import devAssert from "../jsutils/devAssert.mjs";
 import isPromise from "../jsutils/isPromise.mjs";
 import isObjectLike from "../jsutils/isObjectLike.mjs";
-import isCollection from "../jsutils/isCollection.mjs";
+import safeArrayFrom from "../jsutils/safeArrayFrom.mjs";
 import promiseReduce from "../jsutils/promiseReduce.mjs";
 import promiseForObject from "../jsutils/promiseForObject.mjs";
 import { addPath, pathToArray } from "../jsutils/Path.mjs";
@@ -588,15 +587,11 @@ function completeValue(exeContext, returnType, fieldNodes, info, path, result) {
 
 
 function completeListValue(exeContext, returnType, fieldNodes, info, path, result) {
-  if (!isCollection(result)) {
-    throw new GraphQLError("Expected Iterable, but did not find one for field \"".concat(info.parentType.name, ".").concat(info.fieldName, "\"."));
-  } // This is specified as a simple map, however we're optimizing the path
+  // This is specified as a simple map, however we're optimizing the path
   // where the list contains no Promises by avoiding creating another Promise.
-
-
   var itemType = returnType.ofType;
   var containsPromise = false;
-  var completedResults = arrayFrom(result, function (item, index) {
+  var completedResults = safeArrayFrom(result, function (item, index) {
     // No need to modify the info object containing the path,
     // since from here on it is not ever accessed by resolver functions.
     var itemPath = addPath(path, index, undefined);
@@ -628,6 +623,11 @@ function completeListValue(exeContext, returnType, fieldNodes, info, path, resul
       return handleFieldError(error, itemType, exeContext);
     }
   });
+
+  if (completedResults == null) {
+    throw new GraphQLError("Expected Iterable, but did not find one for field \"".concat(info.parentType.name, ".").concat(info.fieldName, "\"."));
+  }
+
   return containsPromise ? Promise.all(completedResults) : completedResults;
 }
 /**

package/jsutils/isAsyncIterable.js

@@ -7,13 +7,7 @@ exports.default = isAsyncIterable;
 
 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); }
-
 // eslint-disable-next-line no-redeclare
 function isAsyncIterable(maybeAsyncIterable) {
-  if (maybeAsyncIterable == null || _typeof(maybeAsyncIterable) !== 'object') {
-    return false;
-  }
-
-  return typeof maybeAsyncIterable[_symbols.SYMBOL_ASYNC_ITERATOR] === 'function';
+  return typeof (maybeAsyncIterable === null || maybeAsyncIterable === void 0 ? void 0 : maybeAsyncIterable[_symbols.SYMBOL_ASYNC_ITERATOR]) === 'function';
 }

package/jsutils/isAsyncIterable.js.flow

@@ -10,9 +10,5 @@ declare function isAsyncIterable(value: mixed): boolean %checks(value instanceof
 
 // eslint-disable-next-line no-redeclare
 export default function isAsyncIterable(maybeAsyncIterable) {
-  if (maybeAsyncIterable == null || typeof maybeAsyncIterable !== 'object') {
-    return false;
-  }
-
-  return typeof maybeAsyncIterable[SYMBOL_ASYNC_ITERATOR] === 'function';
+  return typeof maybeAsyncIterable?.[SYMBOL_ASYNC_ITERATOR] === 'function';
 }

package/jsutils/isAsyncIterable.mjs

@@ -1,5 +1,3 @@
-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_ASYNC_ITERATOR } from "../polyfills/symbols.mjs";
 /**
  * Returns true if the provided object implements the AsyncIterator protocol via
@@ -8,9 +6,5 @@ import { SYMBOL_ASYNC_ITERATOR } from "../polyfills/symbols.mjs";
 
 // eslint-disable-next-line no-redeclare
 export default function isAsyncIterable(maybeAsyncIterable) {
-  if (maybeAsyncIterable == null || _typeof(maybeAsyncIterable) !== 'object') {
-    return false;
-  }
-
-  return typeof maybeAsyncIterable[SYMBOL_ASYNC_ITERATOR] === 'function';
+  return typeof (maybeAsyncIterable === null || maybeAsyncIterable === void 0 ? void 0 : maybeAsyncIterable[SYMBOL_ASYNC_ITERATOR]) === 'function';
 }

package/jsutils/naturalCompare.js

@@ -0,0 +1,69 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = naturalCompare;
+
+/**
+ * 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
+ *
+ */
+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/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/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,6 @@
 // @flow strict
+import naturalCompare from './naturalCompare';
+
 /**
  * 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.
@@ -20,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);
   });
 }