flow-parser 0.321.0 → 0.322.0

package/dist/transform/astNodeMutationHelpers.js

@@ -10,18 +10,13 @@ exports.replaceNodeOnParent = replaceNodeOnParent;
 exports.setParentPointersInDirectChildren = setParentPointersInDirectChildren;
 exports.shallowCloneNode = shallowCloneNode;
 exports.updateAllParentPointers = updateAllParentPointers;
-
 var _astArrayMutationHelpers = require("./astArrayMutationHelpers");
-
 var _getVisitorKeys = require("../traverse/getVisitorKeys");
-
 var _SimpleTraverser = require("../traverse/SimpleTraverser");
-
 function getParentKey(target, parent, visitorKeys) {
   if (parent == null) {
     throw new Error(`Expected parent node to be set on "${target.type}"`);
   }
-
   for (const key of (0, _getVisitorKeys.getVisitorKeys)(parent, visitorKeys)) {
     if ((0, _getVisitorKeys.isNode)(parent[key])) {
       if (parent[key] === target) {
@@ -34,7 +29,6 @@ function getParentKey(target, parent, visitorKeys) {
     } else if (Array.isArray(parent[key])) {
       for (let i = 0; i < parent[key].length; i += 1) {
         const current = parent[key][i];
-
         if (current === target) {
           return {
             type: 'array',
@@ -46,36 +40,29 @@ function getParentKey(target, parent, visitorKeys) {
       }
     }
   }
-
   throw new Error(`Expected to find the ${target.type} as a direct child of the ${parent.type}.`);
 }
-
 function replaceNodeOnParent(originalNode, originalNodeParent, nodeToReplaceWith, visitorKeys) {
   const replacementParent = getParentKey(originalNode, originalNodeParent, visitorKeys);
   const parent = replacementParent.node;
-
   if (replacementParent.type === 'array') {
     parent[replacementParent.key] = (0, _astArrayMutationHelpers.replaceInArray)(parent[replacementParent.key], replacementParent.targetIndex, Array.isArray(nodeToReplaceWith) ? nodeToReplaceWith : [nodeToReplaceWith]);
   } else {
     if (Array.isArray(nodeToReplaceWith)) {
       throw new Error(`Cannot insert array into non-array parent type: ${parent.type}`);
     }
-
     parent[replacementParent.key] = nodeToReplaceWith;
   }
 }
-
 function removeNodeOnParent(originalNode, originalNodeParent, visitorKeys) {
   const replacementParent = getParentKey(originalNode, originalNodeParent, visitorKeys);
   const parent = replacementParent.node;
-
   if (replacementParent.type === 'array') {
     parent[replacementParent.key] = (0, _astArrayMutationHelpers.removeFromArray)(parent[replacementParent.key], replacementParent.targetIndex);
   } else {
     parent[replacementParent.key] = null;
   }
 }
-
 function setParentPointersInDirectChildren(node, visitorKeys) {
   for (const key of (0, _getVisitorKeys.getVisitorKeys)(node, visitorKeys)) {
     if ((0, _getVisitorKeys.isNode)(node[key])) {
@@ -87,54 +74,45 @@ function setParentPointersInDirectChildren(node, visitorKeys) {
     }
   }
 }
-
 function updateAllParentPointers(node, visitorKeys) {
   _SimpleTraverser.SimpleTraverser.traverse(node, {
     enter(node, parent) {
       node.parent = parent;
     },
-
     leave() {},
-
     visitorKeys
   });
 }
-
 function nodeWith(node, overrideProps, visitorKeys) {
   const willBeUnchanged = Object.entries(overrideProps).every(([key, value]) => {
     const node_ = node;
-
     if (Array.isArray(value)) {
       return Array.isArray(node_[key]) ? (0, _astArrayMutationHelpers.arrayIsEqual)(node_[key], value) : false;
     }
-
     return node_[key] === value;
   });
-
   if (willBeUnchanged) {
     return node;
   }
-
-  const newNode = { ...node,
+  const newNode = {
+    ...node,
     ...overrideProps
   };
   setParentPointersInDirectChildren(newNode, visitorKeys);
   return newNode;
 }
-
 function shallowCloneNode(node, visitorKeys) {
-  const newNode = { ...node
+  const newNode = {
+    ...node
   };
   setParentPointersInDirectChildren(newNode, visitorKeys);
   return newNode;
 }
-
 function deepCloneNode(node, visitorKeys) {
   const clone = JSON.parse(JSON.stringify(node, (key, value) => {
     if (key === 'parent') {
       return undefined;
     }
-
     return value;
   }));
   updateAllParentPointers(clone, visitorKeys);

package/dist/transform/print/comments/comments.js

@@ -21,25 +21,14 @@ exports.makeCommentOwnLine = makeCommentOwnLine;
 exports.moveCommentsToNewNode = moveCommentsToNewNode;
 exports.mutateESTreeASTCommentsForPrettier = mutateESTreeASTCommentsForPrettier;
 exports.setCommentsOnNode = setCommentsOnNode;
-
 var _comments = require("./prettier/main/comments");
-
 var _loc = require("./prettier/language-js/loc");
-
 var _printerEstree = _interopRequireDefault(require("./prettier/language-js/printer-estree"));
-
 var _util = require("./prettier/common/util");
-
 var _flowEstree = require("flow-estree");
-
 var _os = require("os");
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-const CommentPlacement = require("flow-enums-runtime").Mirrored(["LEADING_OWN_LINE", "LEADING_INLINE", "TRAILING_OWN_LINE", "TRAILING_INLINE"]);
-
-exports.CommentPlacement = CommentPlacement;
-
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const CommentPlacement = exports.CommentPlacement = require("flow-enums-runtime").Mirrored(["LEADING_OWN_LINE", "LEADING_INLINE", "TRAILING_OWN_LINE", "TRAILING_INLINE"]);
 function attachComments(comments, ast, text) {
   (0, _comments.attach)(comments, ast, text, {
     locStart: _loc.locStart,
@@ -47,28 +36,22 @@ function attachComments(comments, ast, text) {
     printer: _printerEstree.default
   });
 }
-
 function mutateESTreeASTCommentsForPrettier(program, text) {
   let code = text;
   delete program.comments;
-
   if (program.docblock != null && program.docblock.comment != null) {
     const docblockComment = program.docblock.comment;
     const isDocblockCommentNew = !isAttachedComment(docblockComment);
-
     if (isDocblockCommentNew) {
       docblockComment.printed = false;
       docblockComment.leading = true;
       docblockComment.trailing = false;
     }
-
     if (program.body.length > 0) {
       const firstStatement = program.body[0];
       const leadingComments = getLeadingCommentsForNode(firstStatement);
-
       if (!leadingComments.includes(docblockComment)) {
         setCommentsOnNode(firstStatement, [docblockComment, ...getCommentsForNode(firstStatement)]);
-
         if (isDocblockCommentNew) {
           code = makeCommentOwnLine(code, docblockComment);
         }
@@ -77,57 +60,44 @@ function mutateESTreeASTCommentsForPrettier(program, text) {
       setCommentsOnNode(program, [docblockComment]);
     }
   }
-
   delete program.docblock;
   return code;
 }
-
 function moveCommentsToNewNode(oldNode, newNode) {
   setCommentsOnNode(newNode, getCommentsForNode(oldNode));
   setCommentsOnNode(oldNode, []);
 }
-
 function cloneCommentsToNewNode(oldNode, newNode) {
   setCommentsOnNode(newNode, getCommentsForNode(oldNode).map(comment => cloneCommentWithMarkers(comment)));
 }
-
 function cloneJSDocCommentsToNewNode(oldNode, newNode) {
   const comments = getCommentsForNode(oldNode).filter(comment => {
     return (0, _flowEstree.isBlockComment)(comment) && comment.value.startsWith('*');
   });
   setCommentsOnNode(newNode, [...getCommentsForNode(newNode), ...comments.map(cloneCommentWithMarkers)]);
 }
-
 function setCommentsOnNode(node, comments) {
   node.comments = comments;
 }
-
 function getCommentsForNode(node) {
   var _node$comments;
-
   return (_node$comments = node.comments) != null ? _node$comments : [];
 }
-
 function isAttachedComment(comment) {
   return comment.printed === false;
 }
-
 function isLeadingComment(comment) {
   return comment.leading === true;
 }
-
 function isTrailingComment(comment) {
   return comment.trailing === true;
 }
-
 function getLeadingCommentsForNode(node) {
   return getCommentsForNode(node).filter(isLeadingComment);
 }
-
 function getTrailingCommentsForNode(node) {
   return getCommentsForNode(node).filter(isTrailingComment);
 }
-
 function addComment(node, comment, placement) {
   switch (placement) {
     case CommentPlacement.LEADING_OWN_LINE:
@@ -136,7 +106,6 @@ function addComment(node, comment, placement) {
         (0, _util.addLeadingComment)(node, comment);
         break;
       }
-
     case CommentPlacement.TRAILING_OWN_LINE:
     case CommentPlacement.TRAILING_INLINE:
       {
@@ -145,7 +114,6 @@ function addComment(node, comment, placement) {
       }
   }
 }
-
 function cloneComment(comment) {
   return {
     type: comment.type,
@@ -154,7 +122,6 @@ function cloneComment(comment) {
     range: comment.range
   };
 }
-
 function cloneCommentWithMarkers(comment) {
   return {
     type: comment.type,
@@ -165,31 +132,24 @@ function cloneCommentWithMarkers(comment) {
     trailing: isTrailingComment(comment)
   };
 }
-
 function getFirstNewlineIndex(code) {
   return code.search(/\r\n|\n|\r/);
 }
-
 function getFirstNonWhitespaceIndex(code) {
   return code.search(/\S/);
 }
-
 function makeCommentOwnLine(code, comment) {
   let newCode = code;
   let firstNewline = getFirstNewlineIndex(code);
-
   if (firstNewline === -1) {
     newCode += _os.EOL;
     firstNewline = newCode.length;
   }
-
   comment.range = [firstNewline + 1, firstNewline];
   return newCode;
 }
-
 function appendCommentToSource(code, comment, placement) {
   let newCode = code;
-
   switch (comment.type) {
     case 'Block':
       {
@@ -200,39 +160,31 @@ function appendCommentToSource(code, comment, placement) {
               newCode = makeCommentOwnLine(code, comment);
               break;
             }
-
           case CommentPlacement.LEADING_INLINE:
           case CommentPlacement.TRAILING_INLINE:
             {
               let firstNonWhitespace = getFirstNonWhitespaceIndex(code);
-
               if (firstNonWhitespace === -1) {
                 newCode += '$FORCE_INLINE_ON_EMPTY_FILE_TOKEN$;';
                 firstNonWhitespace = newCode.length;
                 break;
               }
-
               comment.range = [firstNonWhitespace + 1, firstNonWhitespace];
               break;
             }
         }
-
         break;
       }
-
     case 'Line':
       {
         const commentText = `//${comment.value}`;
         const lastChar = newCode[newCode.length - 1];
-
         if (lastChar !== '\n' && lastChar !== '\r') {
           newCode += _os.EOL;
         }
-
         if (placement === CommentPlacement.TRAILING_INLINE) {
           newCode += '$FORCE_END_OF_LINE_COMMENT_TOKEN$;';
         }
-
         const start = newCode.length;
         newCode += commentText;
         const end = newCode.length;
@@ -240,6 +192,5 @@ function appendCommentToSource(code, comment, placement) {
         break;
       }
   }
-
   return newCode;
 }

package/dist/transform/print/comments/prettier/common/util.js

@@ -1,27 +1,20 @@
 'use strict';
 
 const stringWidth = require('string-width');
-
 const getLast = require('../utils/get-last.js');
-
 const notAsciiRegex = /[^\x20-\x7F]/;
-
 function skip(chars) {
   return (text, index, opts) => {
     const backwards = opts && opts.backwards;
-
     if (index === false) {
       return false;
     }
-
     const {
       length
     } = text;
     let cursor = index;
-
     while (cursor >= 0 && cursor < length) {
       const c = text.charAt(cursor);
-
       if (chars instanceof RegExp) {
         if (!chars.test(c)) {
           return cursor;
@@ -29,28 +22,22 @@ function skip(chars) {
       } else if (!chars.includes(c)) {
         return cursor;
       }
-
       backwards ? cursor-- : cursor++;
     }
-
     if (cursor === -1 || cursor === length) {
       return cursor;
     }
-
     return false;
   };
 }
-
 const skipWhitespace = skip(/\s/);
 const skipSpaces = skip(' \t');
 const skipToLineEnd = skip(',; \t');
 const skipEverythingButNewLine = skip(/[^\n\r]/);
-
 function skipInlineComment(text, index) {
   if (index === false) {
     return false;
   }
-
   if (text.charAt(index) === '/' && text.charAt(index + 1) === '*') {
     for (let i = index + 2; i < text.length; ++i) {
       if (text.charAt(i) === '*' && text.charAt(i + 1) === '/') {
@@ -58,36 +45,27 @@ function skipInlineComment(text, index) {
       }
     }
   }
-
   return index;
 }
-
 function skipTrailingComment(text, index) {
   if (index === false) {
     return false;
   }
-
   if (text.charAt(index) === '/' && text.charAt(index + 1) === '/') {
     return skipEverythingButNewLine(text, index);
   }
-
   return index;
 }
-
 function skipNewline(text, index, opts) {
   const backwards = opts && opts.backwards;
-
   if (index === false) {
     return false;
   }
-
   const atIndex = text.charAt(index);
-
   if (backwards) {
     if (text.charAt(index - 1) === '\r' && atIndex === '\n') {
       return index - 2;
     }
-
     if (atIndex === '\n' || atIndex === '\r' || atIndex === '\u2028' || atIndex === '\u2029') {
       return index - 1;
     }
@@ -95,51 +73,41 @@ function skipNewline(text, index, opts) {
     if (atIndex === '\r' && text.charAt(index + 1) === '\n') {
       return index + 2;
     }
-
     if (atIndex === '\n' || atIndex === '\r' || atIndex === '\u2028' || atIndex === '\u2029') {
       return index + 1;
     }
   }
-
   return index;
 }
-
 function hasNewline(text, index, opts = {}) {
   const idx = skipSpaces(text, opts.backwards ? index - 1 : index, opts);
   const idx2 = skipNewline(text, idx, opts);
   return idx !== idx2;
 }
-
 function hasNewlineInRange(text, start, end) {
   for (let i = start; i < end; ++i) {
     if (text.charAt(i) === '\n') {
       return true;
     }
   }
-
   return false;
 }
-
 function isNextLineEmptyAfterIndex(text, index) {
   let oldIdx = null;
   let idx = index;
-
   while (idx !== oldIdx) {
     oldIdx = idx;
     idx = skipToLineEnd(text, idx);
     idx = skipInlineComment(text, idx);
     idx = skipSpaces(text, idx);
   }
-
   idx = skipTrailingComment(text, idx);
   idx = skipNewline(text, idx);
   return idx !== false && hasNewline(text, idx);
 }
-
 function getNextNonSpaceNonCommentCharacterIndexWithStartIndex(text, idx) {
   let oldIdx = null;
   let nextIdx = idx;
-
   while (nextIdx !== oldIdx) {
     oldIdx = nextIdx;
     nextIdx = skipSpaces(text, nextIdx);
@@ -147,75 +115,58 @@ function getNextNonSpaceNonCommentCharacterIndexWithStartIndex(text, idx) {
     nextIdx = skipTrailingComment(text, nextIdx);
     nextIdx = skipNewline(text, nextIdx);
   }
-
   return nextIdx;
 }
-
 function getNextNonSpaceNonCommentCharacterIndex(text, node, locEnd) {
   return getNextNonSpaceNonCommentCharacterIndexWithStartIndex(text, locEnd(node));
 }
-
 function getNextNonSpaceNonCommentCharacter(text, node, locEnd) {
   return text.charAt(getNextNonSpaceNonCommentCharacterIndex(text, node, locEnd));
 }
-
 function getStringWidth(text) {
   if (!text) {
     return 0;
   }
-
   if (!notAsciiRegex.test(text)) {
     return text.length;
   }
-
   return stringWidth(text);
 }
-
 function addCommentHelper(node, comment) {
   const comments = node.comments || (node.comments = []);
   comments.push(comment);
   comment.printed = false;
   comment.nodeDescription = describeNodeForDebugging(node);
 }
-
 function addLeadingComment(node, comment) {
   comment.leading = true;
   comment.trailing = false;
   addCommentHelper(node, comment);
 }
-
 function addDanglingComment(node, comment, marker) {
   comment.leading = false;
   comment.trailing = false;
-
   if (marker) {
     comment.marker = marker;
   }
-
   addCommentHelper(node, comment);
 }
-
 function addTrailingComment(node, comment) {
   comment.leading = false;
   comment.trailing = true;
   addCommentHelper(node, comment);
 }
-
 function isNonEmptyArray(object) {
   return Array.isArray(object) && object.length > 0;
 }
-
 function describeNodeForDebugging(node) {
   const nodeType = node.type || node.kind || '(unknown type)';
   let nodeName = String(node.name || node.id && (typeof node.id === 'object' ? node.id.name : node.id) || node.key && (typeof node.key === 'object' ? node.key.name : node.key) || node.value && (typeof node.value === 'object' ? '' : String(node.value)) || node.operator || '');
-
   if (nodeName.length > 20) {
     nodeName = nodeName.slice(0, 19) + '…';
   }
-
   return nodeType + (nodeName ? ' ' + nodeName : '');
 }
-
 module.exports = {
   getStringWidth,
   getLast,