graphql 16.0.1 → 16.1.0

package/language/blockString.js

@@ -3,10 +3,12 @@
 Object.defineProperty(exports, '__esModule', {
   value: true,
 });
-exports.dedentBlockStringValue = dedentBlockStringValue;
-exports.getBlockStringIndentation = getBlockStringIndentation;
+exports.dedentBlockStringLines = dedentBlockStringLines;
+exports.isPrintableAsBlockString = isPrintableAsBlockString;
 exports.printBlockString = printBlockString;
 
+var _characterClasses = require('./characterClasses.js');
+
 /**
  * Produces the value of a block string from its parsed raw value, similar to
  * CoffeeScript's block string, Python's docstring trim or Ruby's strip_heredoc.
@@ -15,94 +17,128 @@ exports.printBlockString = printBlockString;
  *
  * @internal
  */
-function dedentBlockStringValue(rawString) {
-  // Expand a block string's raw value into independent lines.
-  const lines = rawString.split(/\r\n|[\n\r]/g); // Remove common indentation from all lines but first.
+function dedentBlockStringLines(lines) {
+  var _firstNonEmptyLine2;
 
-  const commonIndent = getBlockStringIndentation(rawString);
+  let commonIndent = Number.MAX_SAFE_INTEGER;
+  let firstNonEmptyLine = null;
+  let lastNonEmptyLine = -1;
 
-  if (commonIndent !== 0) {
-    for (let i = 1; i < lines.length; i++) {
-      lines[i] = lines[i].slice(commonIndent);
-    }
-  } // Remove leading and trailing blank lines.
+  for (let i = 0; i < lines.length; ++i) {
+    var _firstNonEmptyLine;
 
-  let startLine = 0;
+    const line = lines[i];
+    const indent = leadingWhitespace(line);
 
-  while (startLine < lines.length && isBlank(lines[startLine])) {
-    ++startLine;
-  }
+    if (indent === line.length) {
+      continue; // skip empty lines
+    }
 
-  let endLine = lines.length;
+    firstNonEmptyLine =
+      (_firstNonEmptyLine = firstNonEmptyLine) !== null &&
+      _firstNonEmptyLine !== void 0
+        ? _firstNonEmptyLine
+        : i;
+    lastNonEmptyLine = i;
 
-  while (endLine > startLine && isBlank(lines[endLine - 1])) {
-    --endLine;
-  } // Return a string of the lines joined with U+000A.
+    if (i !== 0 && indent < commonIndent) {
+      commonIndent = indent;
+    }
+  }
 
-  return lines.slice(startLine, endLine).join('\n');
+  return lines // Remove common indentation from all lines but first.
+    .map((line, i) => (i === 0 ? line : line.slice(commonIndent))) // Remove leading and trailing blank lines.
+    .slice(
+      (_firstNonEmptyLine2 = firstNonEmptyLine) !== null &&
+        _firstNonEmptyLine2 !== void 0
+        ? _firstNonEmptyLine2
+        : 0,
+      lastNonEmptyLine + 1,
+    );
 }
 
-function isBlank(str) {
-  for (const char of str) {
-    if (char !== ' ' && char !== '\t') {
-      return false;
-    }
+function leadingWhitespace(str) {
+  let i = 0;
+
+  while (
+    i < str.length &&
+    (0, _characterClasses.isWhiteSpace)(str.charCodeAt(i))
+  ) {
+    ++i;
   }
 
-  return true;
+  return i;
 }
 /**
  * @internal
  */
 
-function getBlockStringIndentation(value) {
-  var _commonIndent;
+function isPrintableAsBlockString(value) {
+  if (value === '') {
+    return true; // empty string is printable
+  }
 
-  let isFirstLine = true;
   let isEmptyLine = true;
-  let indent = 0;
-  let commonIndent = null;
+  let hasIndent = false;
+  let hasCommonIndent = true;
+  let seenNonEmptyLine = false;
 
   for (let i = 0; i < value.length; ++i) {
-    switch (value.charCodeAt(i)) {
-      case 13:
+    switch (value.codePointAt(i)) {
+      case 0x0000:
+      case 0x0001:
+      case 0x0002:
+      case 0x0003:
+      case 0x0004:
+      case 0x0005:
+      case 0x0006:
+      case 0x0007:
+      case 0x0008:
+      case 0x000b:
+      case 0x000c:
+      case 0x000e:
+      case 0x000f:
+        return false;
+      // Has non-printable characters
+
+      case 0x000d:
         //  \r
-        if (value.charCodeAt(i + 1) === 10) {
-          ++i; // skip \r\n as one symbol
-        }
-
-      // falls through
+        return false;
+      // Has \r or \r\n which will be replaced as \n
 
       case 10:
         //  \n
-        isFirstLine = false;
+        if (isEmptyLine && !seenNonEmptyLine) {
+          return false; // Has leading new line
+        }
+
+        seenNonEmptyLine = true;
         isEmptyLine = true;
-        indent = 0;
+        hasIndent = false;
         break;
 
       case 9: //   \t
 
       case 32:
         //  <space>
-        ++indent;
+        hasIndent || (hasIndent = isEmptyLine);
         break;
 
       default:
-        if (
-          isEmptyLine &&
-          !isFirstLine &&
-          (commonIndent === null || indent < commonIndent)
-        ) {
-          commonIndent = indent;
-        }
-
+        hasCommonIndent && (hasCommonIndent = hasIndent);
         isEmptyLine = false;
     }
   }
 
-  return (_commonIndent = commonIndent) !== null && _commonIndent !== void 0
-    ? _commonIndent
-    : 0;
+  if (isEmptyLine) {
+    return false; // Has trailing empty lines
+  }
+
+  if (hasCommonIndent && seenNonEmptyLine) {
+    return false; // Has internal indent
+  }
+
+  return true;
 }
 /**
  * Print a block string in the indented block form by adding a leading and
@@ -112,27 +148,48 @@ function getBlockStringIndentation(value) {
  * @internal
  */
 
-function printBlockString(value, preferMultipleLines = false) {
-  const isSingleLine = !value.includes('\n');
-  const hasLeadingSpace = value.startsWith(' ') || value.startsWith('\t');
-  const hasTrailingQuote = value.endsWith('"');
+function printBlockString(value, options) {
+  const escapedValue = value.replace(/"""/g, '\\"""'); // Expand a block string's raw value into independent lines.
+
+  const lines = escapedValue.split(/\r\n|[\n\r]/g);
+  const isSingleLine = lines.length === 1; // If common indentation is found we can fix some of those cases by adding leading new line
+
+  const forceLeadingNewLine =
+    lines.length > 1 &&
+    lines
+      .slice(1)
+      .every(
+        (line) =>
+          line.length === 0 ||
+          (0, _characterClasses.isWhiteSpace)(line.charCodeAt(0)),
+      ); // Trailing triple quotes just looks confusing but doesn't force trailing new line
+
+  const hasTrailingTripleQuotes = escapedValue.endsWith('\\"""'); // Trailing quote (single or double) or slash forces trailing new line
+
+  const hasTrailingQuote = value.endsWith('"') && !hasTrailingTripleQuotes;
   const hasTrailingSlash = value.endsWith('\\');
+  const forceTrailingNewline = hasTrailingQuote || hasTrailingSlash;
   const printAsMultipleLines =
-    !isSingleLine ||
-    hasTrailingQuote ||
-    hasTrailingSlash ||
-    preferMultipleLines;
+    !(options !== null && options !== void 0 && options.minimize) && // add leading and trailing new lines only if it improves readability
+    (!isSingleLine ||
+      value.length > 70 ||
+      forceTrailingNewline ||
+      forceLeadingNewLine ||
+      hasTrailingTripleQuotes);
   let result = ''; // Format a multi-line block quote to account for leading space.
 
-  if (printAsMultipleLines && !(isSingleLine && hasLeadingSpace)) {
+  const skipLeadingNewLine =
+    isSingleLine && (0, _characterClasses.isWhiteSpace)(value.charCodeAt(0));
+
+  if ((printAsMultipleLines && !skipLeadingNewLine) || forceLeadingNewLine) {
     result += '\n';
   }
 
-  result += value;
+  result += escapedValue;
 
-  if (printAsMultipleLines) {
+  if (printAsMultipleLines || forceTrailingNewline) {
     result += '\n';
   }
 
-  return '"""' + result.replace(/"""/g, '\\"""') + '"""';
+  return '"""' + result + '"""';
 }

package/language/blockString.mjs

@@ -1,3 +1,4 @@
+import { isWhiteSpace } from './characterClasses.mjs';
 /**
  * Produces the value of a block string from its parsed raw value, similar to
  * CoffeeScript's block string, Python's docstring trim or Ruby's strip_heredoc.
@@ -6,94 +7,126 @@
  *
  * @internal
  */
-export function dedentBlockStringValue(rawString) {
-  // Expand a block string's raw value into independent lines.
-  const lines = rawString.split(/\r\n|[\n\r]/g); // Remove common indentation from all lines but first.
 
-  const commonIndent = getBlockStringIndentation(rawString);
+export function dedentBlockStringLines(lines) {
+  var _firstNonEmptyLine2;
 
-  if (commonIndent !== 0) {
-    for (let i = 1; i < lines.length; i++) {
-      lines[i] = lines[i].slice(commonIndent);
-    }
-  } // Remove leading and trailing blank lines.
+  let commonIndent = Number.MAX_SAFE_INTEGER;
+  let firstNonEmptyLine = null;
+  let lastNonEmptyLine = -1;
 
-  let startLine = 0;
+  for (let i = 0; i < lines.length; ++i) {
+    var _firstNonEmptyLine;
 
-  while (startLine < lines.length && isBlank(lines[startLine])) {
-    ++startLine;
-  }
+    const line = lines[i];
+    const indent = leadingWhitespace(line);
 
-  let endLine = lines.length;
+    if (indent === line.length) {
+      continue; // skip empty lines
+    }
 
-  while (endLine > startLine && isBlank(lines[endLine - 1])) {
-    --endLine;
-  } // Return a string of the lines joined with U+000A.
+    firstNonEmptyLine =
+      (_firstNonEmptyLine = firstNonEmptyLine) !== null &&
+      _firstNonEmptyLine !== void 0
+        ? _firstNonEmptyLine
+        : i;
+    lastNonEmptyLine = i;
 
-  return lines.slice(startLine, endLine).join('\n');
+    if (i !== 0 && indent < commonIndent) {
+      commonIndent = indent;
+    }
+  }
+
+  return lines // Remove common indentation from all lines but first.
+    .map((line, i) => (i === 0 ? line : line.slice(commonIndent))) // Remove leading and trailing blank lines.
+    .slice(
+      (_firstNonEmptyLine2 = firstNonEmptyLine) !== null &&
+        _firstNonEmptyLine2 !== void 0
+        ? _firstNonEmptyLine2
+        : 0,
+      lastNonEmptyLine + 1,
+    );
 }
 
-function isBlank(str) {
-  for (const char of str) {
-    if (char !== ' ' && char !== '\t') {
-      return false;
-    }
+function leadingWhitespace(str) {
+  let i = 0;
+
+  while (i < str.length && isWhiteSpace(str.charCodeAt(i))) {
+    ++i;
   }
 
-  return true;
+  return i;
 }
 /**
  * @internal
  */
 
-export function getBlockStringIndentation(value) {
-  var _commonIndent;
+export function isPrintableAsBlockString(value) {
+  if (value === '') {
+    return true; // empty string is printable
+  }
 
-  let isFirstLine = true;
   let isEmptyLine = true;
-  let indent = 0;
-  let commonIndent = null;
+  let hasIndent = false;
+  let hasCommonIndent = true;
+  let seenNonEmptyLine = false;
 
   for (let i = 0; i < value.length; ++i) {
-    switch (value.charCodeAt(i)) {
-      case 13:
+    switch (value.codePointAt(i)) {
+      case 0x0000:
+      case 0x0001:
+      case 0x0002:
+      case 0x0003:
+      case 0x0004:
+      case 0x0005:
+      case 0x0006:
+      case 0x0007:
+      case 0x0008:
+      case 0x000b:
+      case 0x000c:
+      case 0x000e:
+      case 0x000f:
+        return false;
+      // Has non-printable characters
+
+      case 0x000d:
         //  \r
-        if (value.charCodeAt(i + 1) === 10) {
-          ++i; // skip \r\n as one symbol
-        }
-
-      // falls through
+        return false;
+      // Has \r or \r\n which will be replaced as \n
 
       case 10:
         //  \n
-        isFirstLine = false;
+        if (isEmptyLine && !seenNonEmptyLine) {
+          return false; // Has leading new line
+        }
+
+        seenNonEmptyLine = true;
         isEmptyLine = true;
-        indent = 0;
+        hasIndent = false;
         break;
 
       case 9: //   \t
 
       case 32:
         //  <space>
-        ++indent;
+        hasIndent || (hasIndent = isEmptyLine);
         break;
 
       default:
-        if (
-          isEmptyLine &&
-          !isFirstLine &&
-          (commonIndent === null || indent < commonIndent)
-        ) {
-          commonIndent = indent;
-        }
-
+        hasCommonIndent && (hasCommonIndent = hasIndent);
         isEmptyLine = false;
     }
   }
 
-  return (_commonIndent = commonIndent) !== null && _commonIndent !== void 0
-    ? _commonIndent
-    : 0;
+  if (isEmptyLine) {
+    return false; // Has trailing empty lines
+  }
+
+  if (hasCommonIndent && seenNonEmptyLine) {
+    return false; // Has internal indent
+  }
+
+  return true;
 }
 /**
  * Print a block string in the indented block form by adding a leading and
@@ -103,27 +136,43 @@ export function getBlockStringIndentation(value) {
  * @internal
  */
 
-export function printBlockString(value, preferMultipleLines = false) {
-  const isSingleLine = !value.includes('\n');
-  const hasLeadingSpace = value.startsWith(' ') || value.startsWith('\t');
-  const hasTrailingQuote = value.endsWith('"');
+export function printBlockString(value, options) {
+  const escapedValue = value.replace(/"""/g, '\\"""'); // Expand a block string's raw value into independent lines.
+
+  const lines = escapedValue.split(/\r\n|[\n\r]/g);
+  const isSingleLine = lines.length === 1; // If common indentation is found we can fix some of those cases by adding leading new line
+
+  const forceLeadingNewLine =
+    lines.length > 1 &&
+    lines
+      .slice(1)
+      .every((line) => line.length === 0 || isWhiteSpace(line.charCodeAt(0))); // Trailing triple quotes just looks confusing but doesn't force trailing new line
+
+  const hasTrailingTripleQuotes = escapedValue.endsWith('\\"""'); // Trailing quote (single or double) or slash forces trailing new line
+
+  const hasTrailingQuote = value.endsWith('"') && !hasTrailingTripleQuotes;
   const hasTrailingSlash = value.endsWith('\\');
+  const forceTrailingNewline = hasTrailingQuote || hasTrailingSlash;
   const printAsMultipleLines =
-    !isSingleLine ||
-    hasTrailingQuote ||
-    hasTrailingSlash ||
-    preferMultipleLines;
+    !(options !== null && options !== void 0 && options.minimize) && // add leading and trailing new lines only if it improves readability
+    (!isSingleLine ||
+      value.length > 70 ||
+      forceTrailingNewline ||
+      forceLeadingNewLine ||
+      hasTrailingTripleQuotes);
   let result = ''; // Format a multi-line block quote to account for leading space.
 
-  if (printAsMultipleLines && !(isSingleLine && hasLeadingSpace)) {
+  const skipLeadingNewLine = isSingleLine && isWhiteSpace(value.charCodeAt(0));
+
+  if ((printAsMultipleLines && !skipLeadingNewLine) || forceLeadingNewLine) {
     result += '\n';
   }
 
-  result += value;
+  result += escapedValue;
 
-  if (printAsMultipleLines) {
+  if (printAsMultipleLines || forceTrailingNewline) {
     result += '\n';
   }
 
-  return '"""' + result.replace(/"""/g, '\\"""') + '"""';
+  return '"""' + result + '"""';
 }

package/language/characterClasses.d.ts

@@ -1,3 +1,12 @@
+/**
+ * ```
+ * WhiteSpace ::
+ *   - "Horizontal Tab (U+0009)"
+ *   - "Space (U+0020)"
+ * ```
+ * @internal
+ */
+export declare function isWhiteSpace(code: number): boolean;
 /**
  * ```
  * Digit :: one of

package/language/characterClasses.js

@@ -7,7 +7,19 @@ exports.isDigit = isDigit;
 exports.isLetter = isLetter;
 exports.isNameContinue = isNameContinue;
 exports.isNameStart = isNameStart;
+exports.isWhiteSpace = isWhiteSpace;
 
+/**
+ * ```
+ * WhiteSpace ::
+ *   - "Horizontal Tab (U+0009)"
+ *   - "Space (U+0020)"
+ * ```
+ * @internal
+ */
+function isWhiteSpace(code) {
+  return code === 0x0009 || code === 0x0020;
+}
 /**
  * ```
  * Digit :: one of
@@ -15,6 +27,7 @@ exports.isNameStart = isNameStart;
  * ```
  * @internal
  */
+
 function isDigit(code) {
   return code >= 0x0030 && code <= 0x0039;
 }

package/language/characterClasses.mjs

@@ -1,3 +1,14 @@
+/**
+ * ```
+ * WhiteSpace ::
+ *   - "Horizontal Tab (U+0009)"
+ *   - "Space (U+0020)"
+ * ```
+ * @internal
+ */
+export function isWhiteSpace(code) {
+  return code === 0x0009 || code === 0x0020;
+}
 /**
  * ```
  * Digit :: one of
@@ -5,6 +16,7 @@
  * ```
  * @internal
  */
+
 export function isDigit(code) {
   return code >= 0x0030 && code <= 0x0039;
 }

package/language/lexer.js

@@ -893,11 +893,11 @@ function readEscapedCharacter(lexer, position) {
 function readBlockString(lexer, start) {
   const body = lexer.source.body;
   const bodyLength = body.length;
-  const startLine = lexer.line;
-  const startColumn = 1 + start - lexer.lineStart;
+  let lineStart = lexer.lineStart;
   let position = start + 3;
   let chunkStart = position;
-  let rawValue = '';
+  let currentLine = '';
+  const blockLines = [];
 
   while (position < bodyLength) {
     const code = body.charCodeAt(position); // Closing Triple-Quote (""")
@@ -907,15 +907,18 @@ function readBlockString(lexer, start) {
       body.charCodeAt(position + 1) === 0x0022 &&
       body.charCodeAt(position + 2) === 0x0022
     ) {
-      rawValue += body.slice(chunkStart, position);
-      return new _ast.Token(
+      currentLine += body.slice(chunkStart, position);
+      blockLines.push(currentLine);
+      const token = createToken(
+        lexer,
         _tokenKind.TokenKind.BLOCK_STRING,
         start,
-        position + 3,
-        startLine,
-        startColumn,
-        (0, _blockString.dedentBlockStringValue)(rawValue),
+        position + 3, // Return a string of the lines joined with U+000A.
+        (0, _blockString.dedentBlockStringLines)(blockLines).join('\n'),
       );
+      lexer.line += blockLines.length - 1;
+      lexer.lineStart = lineStart;
+      return token;
     } // Escaped Triple-Quote (\""")
 
     if (
@@ -924,21 +927,26 @@ function readBlockString(lexer, start) {
       body.charCodeAt(position + 2) === 0x0022 &&
       body.charCodeAt(position + 3) === 0x0022
     ) {
-      rawValue += body.slice(chunkStart, position) + '"""';
+      currentLine += body.slice(chunkStart, position);
+      chunkStart = position + 1; // skip only slash
+
       position += 4;
-      chunkStart = position;
       continue;
     } // LineTerminator
 
     if (code === 0x000a || code === 0x000d) {
+      currentLine += body.slice(chunkStart, position);
+      blockLines.push(currentLine);
+
       if (code === 0x000d && body.charCodeAt(position + 1) === 0x000a) {
         position += 2;
       } else {
         ++position;
       }
 
-      ++lexer.line;
-      lexer.lineStart = position;
+      currentLine = '';
+      chunkStart = position;
+      lineStart = position;
       continue;
     } // SourceCharacter