{"action":"created","issue":{"url":"https://api.github.com/repos/patrykomiotek/seo-monitor-front/issues/92","repository_url":"https://api.github.com/repos/patrykomiotek/seo-monitor-front","labels_url":"https://api.github.com/repos/patrykomiotek/seo-monitor-front/issues/92/labels{/name}","comments_url":"https://api.github.com/repos/patrykomiotek/seo-monitor-front/issues/92/comments","events_url":"https://api.github.com/repos/patrykomiotek/seo-monitor-front/issues/92/events","html_url":"https://github.com/patrykomiotek/seo-monitor-front/pull/92","id":233236463,"node_id":"MDExOlB1bGxSZXF1ZXN0MTIzNzU1MDQz","number":92,"title":"Update prettier to the latest version 🚀","user":{"login":"greenkeeper[bot]","id":23040076,"node_id":"MDM6Qm90MjMwNDAwNzY=","avatar_url":"https://avatars3.githubusercontent.com/in/505?v=4","gravatar_id":"","url":"https://api.github.com/users/greenkeeper%5Bbot%5D","html_url":"https://github.com/apps/greenkeeper","followers_url":"https://api.github.com/users/greenkeeper%5Bbot%5D/followers","following_url":"https://api.github.com/users/greenkeeper%5Bbot%5D/following{/other_user}","gists_url":"https://api.github.com/users/greenkeeper%5Bbot%5D/gists{/gist_id}","starred_url":"https://api.github.com/users/greenkeeper%5Bbot%5D/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/greenkeeper%5Bbot%5D/subscriptions","organizations_url":"https://api.github.com/users/greenkeeper%5Bbot%5D/orgs","repos_url":"https://api.github.com/users/greenkeeper%5Bbot%5D/repos","events_url":"https://api.github.com/users/greenkeeper%5Bbot%5D/events{/privacy}","received_events_url":"https://api.github.com/users/greenkeeper%5Bbot%5D/received_events","type":"Bot","site_admin":false},"labels":[{"id":544929219,"node_id":"MDU6TGFiZWw1NDQ5MjkyMTk=","url":"https://api.github.com/repos/patrykomiotek/seo-monitor-front/labels/greenkeeper","name":"greenkeeper","color":"00c775","default":false}],"state":"open","locked":false,"assignee":null,"assignees":[],"milestone":null,"comments":35,"created_at":"2017-06-02T16:32:42Z","updated_at":"2018-06-08T18:34:43Z","closed_at":null,"author_association":"NONE","pull_request":{"url":"https://api.github.com/repos/patrykomiotek/seo-monitor-front/pulls/92","html_url":"https://github.com/patrykomiotek/seo-monitor-front/pull/92","diff_url":"https://github.com/patrykomiotek/seo-monitor-front/pull/92.diff","patch_url":"https://github.com/patrykomiotek/seo-monitor-front/pull/92.patch"},"body":"\n## Version **1.4.0** of [prettier](https://github.com/prettier/prettier) just got published.\n\n<table>\n  <tr>\n    <th align=left>\n      Dependency\n    </td>\n    <td>\n      prettier\n    </td>\n  </tr>\n  <tr>\n    <th align=left>\n      Current Version\n    </td>\n    <td>\n      0.19.0\n    </td>\n  </tr>\n  <tr>\n    <th align=left>\n      Type\n    </td>\n    <td>\n      devDependency\n    </td>\n  </tr>\n</table>\n\nThe version **1.4.0** is **not covered** by your **current version range**.\n\nWithout accepting this pull request your project will work just like it did before. There might be a bunch of new features, fixes and perf improvements that the maintainers worked on for you though.\n\nI recommend you look into these changes and try to get onto the latest version of prettier.\nGiven that you have a decent test suite, a passing build is a strong indicator that you can take advantage of these changes by merging the proposed change into your project. Otherwise this branch is a great starting point for you to work on the update.\n\n\n---\n\n\n<details>\n<summary>Release Notes</summary>\n<strong>1.4.0: TypeScript and CSS support</strong>\n\n<p><a href=\"https://revolutionconf.com/talk/a-prettier-printer\"><img src=\"https://cloud.githubusercontent.com/assets/197597/26732495/9f1101b6-476c-11e7-8d19-56a17e2080c5.png\" alt=\"prettier-revolution-conf\" style=\"max-width:100%;\"></a></p>\n<h1>TypeScript Support</h1>\n<p>This is the most requested feature for prettier. With 1.4.0, you can now use prettier to format your <code>.ts</code> and <code>.tsx</code> files!</p>\n<p>The way prettier works is by using those project to generate an AST representation of the code and print it. Both babylon (the parser that powers babel) and flow are producing an AST approximately following the <a href=\"https://urls.greenkeeper.io/estree/estree\">estree</a> format for the JavaScript parts and then have special nodes for Flow-specific ones.</p>\n<p>TypeScript, the same way as Flow, introduces special nodes for the syntax it introduces. Unfortunately, it doesn't follow the estree format for the rest of the JavaScript language. This puts us in a rough spot with prettier as we would have to essentially completely fork it in order to print TypeScript.</p>\n<p>This incompatibility with the AST is not a new problem and another project struggled with it: ESLint. Because the AST is different, none of the ESLint rules are working. Fortunately for us, <a href=\"https://urls.greenkeeper.io/jameshenry\" class=\"user-mention\">@JamesHenry</a> and <a href=\"https://urls.greenkeeper.io/soda0289\" class=\"user-mention\">@soda0289</a> wrote a project called <a href=\"https://urls.greenkeeper.io/eslint/typescript-eslint-parser\">typescript-eslint-parser</a> which takes a TypeScript AST and convert it to an estree one, just what we need for prettier!</p>\n<p>After that project got setup inside of prettier, <a href=\"https://urls.greenkeeper.io/azz\" class=\"user-mention\">@azz</a>, <a href=\"https://urls.greenkeeper.io/despairblue\" class=\"user-mention\">@despairblue</a> and <a href=\"https://urls.greenkeeper.io/pajn\" class=\"user-mention\">@Pajn</a> implemented all the TypeScript-specific nodes and ensured that the 13k tests of the TypeScript test suite are correctly passing. This was a huge undertaking and it is finally ready to be used :)</p>\n<p>We tested prettier on the biggest TypeScript projects we could find on GitHub to ensure that it prints correct code. We haven't spent a lot of time trying to optimize the way code is formatted yet, so if you see something strange, please raise an issue!</p>\n<h1>CSS, Less and SCSS Support</h1>\n<p>While TypeScript is the most requested feature from open source, CSS is the biggest one from Facebook engineers. Once you are used to pretty print your code in one language, you want to do it everywhere!</p>\n<p>It turns out that CSS is a much smaller language than JavaScript and supporting it only took a few days. We are using <a href=\"https://urls.greenkeeper.io/postcss/postcss\">postcss</a> by <a href=\"https://urls.greenkeeper.io/ai\" class=\"user-mention\">@ai</a> as the underlying parser which is able to parse CSS, Less and SCSS. We also depend on <a href=\"https://urls.greenkeeper.io/shellscape/postcss-values-parser\">postcss-values-parser</a>, <a href=\"https://urls.greenkeeper.io/postcss/postcss-selector-parser\">postcss-selector-parser</a> by <a href=\"https://urls.greenkeeper.io/ben-eb\" class=\"user-mention\">@ben-eb</a>  <a href=\"https://urls.greenkeeper.io/dryoma/postcss-media-query-parser\">postcss-media-query-parser</a> by <a href=\"https://urls.greenkeeper.io/dryoma\" class=\"user-mention\">@dryoma</a>.</p>\n<p>Unfortunately, postcss right now doesn't parse Sass nor Stylus. We'd be happy to support them if someone is willing to do the work of printing them.</p>\n<p>Note that prettier is currently just formatting the code, it does not respect any options yet such as <code>singleQuote</code> nor is doing any color or number normalization like we do for JavaScript.</p>\n<h1>Editor Integration</h1>\n<p>The first phase of the project was to make prettier output correct and good looking code. Now that it's in a good shape, we can spend time on making the integrations better. We just introduced support for two great features: maintain cursor position and being able to format a range instead of the entire file.</p>\n<p>Note that we just landed the support inside of prettier itself, none of the editor integrations are using it yet. Also, we haven't really tried them out in practice so we're likely going to have to fix rough edges with them!</p>\n<h3>Add <code>cursorOffset</code> option for cursor translation (<a href=\"https://urls.greenkeeper.io/prettier/prettier/pull/1637\" class=\"issue-link js-issue-link\" data-url=\"https://github.com/prettier/prettier/issues/1637\" data-id=\"230127692\" data-error-text=\"Failed to load issue title\" data-permission-text=\"Issue title is private\">#1637</a>) by <a href=\"https://urls.greenkeeper.io/josephfrazier\" class=\"user-mention\">@josephfrazier</a></h3>\n<p>Right now, we let editors figure out where the cursor should be, which they do an okay job at. But since we are printing the code, we can give the correct position!</p>\n<h3>Add <code>--range-start/end</code> options to format only parts of the input (<a href=\"https://urls.greenkeeper.io/prettier/prettier/pull/1609\" class=\"issue-link js-issue-link\" data-url=\"https://github.com/prettier/prettier/issues/1609\" data-id=\"228586057\" data-error-text=\"Failed to load issue title\" data-permission-text=\"Issue title is private\">#1609</a>) by <a href=\"https://urls.greenkeeper.io/josephfrazier\" class=\"user-mention\">@josephfrazier</a></h3>\n<p>This one is a very often requested feature. Right now prettier only formats the entire file. Now it is possible to format a range.</p>\n<p>The way it works is by going up through the AST in order to find the closest statement. This way you don't need to select exactly the right range that is valid. You can just drag in the rough place where the code you want to reformat it, and it's going to!</p>\n<h3>Adding filepath option in order to enable filetype inference (<a href=\"https://urls.greenkeeper.io/prettier/prettier/pull/1835\" class=\"issue-link js-issue-link\" data-url=\"https://github.com/prettier/prettier/issues/1835\" data-id=\"232654641\" data-error-text=\"Failed to load issue title\" data-permission-text=\"Issue title is private\">#1835</a>) by <a href=\"https://urls.greenkeeper.io/mitermayer\" class=\"user-mention\">@mitermayer</a></h3>\n<p>Since we are now formatting CSS and TypeScript, it is not convenient to have to specify the parser for every file. You can now pass the filepath of the file you are working on and prettier will read the extension and figure out the right parser to use.</p>\n<h1>Highlights</h1>\n<h3>Wrap text content inside of JSX (<a href=\"https://urls.greenkeeper.io/prettier/prettier/pull/1120\" class=\"issue-link js-issue-link\" data-url=\"https://github.com/prettier/prettier/issues/1120\" data-id=\"219561863\" data-error-text=\"Failed to load issue title\" data-permission-text=\"Issue title is private\">#1120</a>, <a href=\"https://urls.greenkeeper.io/prettier/prettier/pull/1671\" class=\"issue-link js-issue-link\" data-url=\"https://github.com/prettier/prettier/issues/1671\" data-id=\"230635503\" data-error-text=\"Failed to load issue title\" data-permission-text=\"Issue title is private\">#1671</a>, <a href=\"https://urls.greenkeeper.io/prettier/prettier/pull/1827\" class=\"issue-link js-issue-link\" data-url=\"https://github.com/prettier/prettier/issues/1827\" data-id=\"232518231\" data-error-text=\"Failed to load issue title\" data-permission-text=\"Issue title is private\">#1827</a>, <a href=\"https://urls.greenkeeper.io/prettier/prettier/pull/1829\" class=\"issue-link js-issue-link\" data-url=\"https://github.com/prettier/prettier/issues/1829\" data-id=\"232536920\" data-error-text=\"Failed to load issue title\" data-permission-text=\"Issue title is private\">#1829</a>) by <a href=\"https://urls.greenkeeper.io/karl\" class=\"user-mention\">@karl</a></h3>\n<p>The biggest remaining issue that people have with prettier when printing JSX is when it is used when printing text. The behavior of prettier used to add an ugly <code>{\" \"}</code> before and if a line was too long, just leave it alone. Now we treat each word as a token and are able to make it flow correctly.</p>\n<p>This is an awesome piece of work by <a href=\"https://urls.greenkeeper.io/karl\" class=\"user-mention\">@karl</a> as not only did he implement the feature, but also introduced a new primitive inside of prettier in order to print a sequence of elements and break as soon as one hits the edge.</p>\n<div class=\"highlight highlight-source-js\"><pre><span class=\"pl-c\"><span class=\"pl-c\">//</span> Before</span>\n<span class=\"pl-k\">&lt;</span>div<span class=\"pl-k\">&gt;</span>\n  Please state your\n  {<span class=\"pl-s\"><span class=\"pl-pds\">\"</span> <span class=\"pl-pds\">\"</span></span>}\n  <span class=\"pl-k\">&lt;</span>b<span class=\"pl-k\">&gt;</span>name<span class=\"pl-k\">&lt;</span><span class=\"pl-k\">/</span>b<span class=\"pl-k\">&gt;</span>\n  {<span class=\"pl-s\"><span class=\"pl-pds\">\"</span> <span class=\"pl-pds\">\"</span></span>}\n  and\n  {<span class=\"pl-s\"><span class=\"pl-pds\">\"</span> <span class=\"pl-pds\">\"</span></span>}\n  <span class=\"pl-k\">&lt;</span>b<span class=\"pl-k\">&gt;</span>occupation<span class=\"pl-k\">&lt;</span><span class=\"pl-k\">/</span>b<span class=\"pl-k\">&gt;</span>\n  {<span class=\"pl-s\"><span class=\"pl-pds\">\"</span> <span class=\"pl-pds\">\"</span></span>}\n  <span class=\"pl-k\">for</span> the board <span class=\"pl-k\">of</span> directors.\n<span class=\"pl-k\">&lt;</span><span class=\"pl-k\">/</span>div<span class=\"pl-k\">&gt;</span>\n\n<span class=\"pl-c\"><span class=\"pl-c\">//</span> After</span>\n<span class=\"pl-k\">&lt;</span>div<span class=\"pl-k\">&gt;</span>\n  Please state your <span class=\"pl-k\">&lt;</span>b<span class=\"pl-k\">&gt;</span>name<span class=\"pl-k\">&lt;</span><span class=\"pl-k\">/</span>b<span class=\"pl-k\">&gt;</span> and <span class=\"pl-k\">&lt;</span>b<span class=\"pl-k\">&gt;</span>occupation<span class=\"pl-k\">&lt;</span><span class=\"pl-k\">/</span>b<span class=\"pl-k\">&gt;</span> <span class=\"pl-k\">for</span> the board <span class=\"pl-k\">of</span>\n  directors.\n<span class=\"pl-k\">&lt;</span><span class=\"pl-k\">/</span>div<span class=\"pl-k\">&gt;</span></pre></div>\n<h3>Remove parenthesis for JSX inside of arrow functions (<a href=\"https://urls.greenkeeper.io/prettier/prettier/pull/1733\" class=\"issue-link js-issue-link\" data-url=\"https://github.com/prettier/prettier/issues/1733\" data-id=\"231401959\" data-error-text=\"Failed to load issue title\" data-permission-text=\"Issue title is private\">#1733</a>) by <a href=\"https://urls.greenkeeper.io/xixixao\" class=\"user-mention\">@xixixao</a></h3>\n<p>People writing functional components are going to be happy about this one. We no longer put parens for arrow functions that return JSX.</p>\n<div class=\"highlight highlight-source-js\"><pre><span class=\"pl-c\"><span class=\"pl-c\">//</span> Before</span>\n<span class=\"pl-k\">const</span> <span class=\"pl-c1\">render1</span> <span class=\"pl-k\">=</span> ({ styles }) <span class=\"pl-k\">=&gt;</span> (\n  <span class=\"pl-k\">&lt;</span>div style<span class=\"pl-k\">=</span>{styles}<span class=\"pl-k\">&gt;</span>\n      Keep the wrapping <span class=\"pl-smi\">parens</span>. <span class=\"pl-smi\">Put</span> each key on its own line.\n  <span class=\"pl-k\">&lt;</span><span class=\"pl-k\">/</span>div<span class=\"pl-k\">&gt;</span>\n);\n\n<span class=\"pl-c\"><span class=\"pl-c\">//</span> After</span>\n<span class=\"pl-k\">const</span> <span class=\"pl-c1\">render1</span> <span class=\"pl-k\">=</span> ({ styles }) <span class=\"pl-k\">=&gt;</span>\n  <span class=\"pl-k\">&lt;</span>div style<span class=\"pl-k\">=</span>{styles}<span class=\"pl-k\">&gt;</span>\n      Keep the wrapping <span class=\"pl-smi\">parens</span>. <span class=\"pl-smi\">Put</span> each key on its own line.\n  <span class=\"pl-k\">&lt;</span><span class=\"pl-k\">/</span>div<span class=\"pl-k\">&gt;</span>;</pre></div>\n<h3>Improve template literal printing (<a href=\"https://urls.greenkeeper.io/prettier/prettier/pull/1664\" class=\"issue-link js-issue-link\" data-url=\"https://github.com/prettier/prettier/issues/1664\" data-id=\"230432363\" data-error-text=\"Failed to load issue title\" data-permission-text=\"Issue title is private\">#1664</a>, <a href=\"https://urls.greenkeeper.io/prettier/prettier/pull/1714\" class=\"issue-link js-issue-link\" data-url=\"https://github.com/prettier/prettier/issues/1714\" data-id=\"231156285\" data-error-text=\"Failed to load issue title\" data-permission-text=\"Issue title is private\">#1714</a>) by <a href=\"https://urls.greenkeeper.io/josephfrazier\" class=\"user-mention\">@josephfrazier</a></h3>\n<p>Template literal printing has always caused prettier a lot of difficulties. With 1.3.0 we massively improved the situation and with this release, I believe that we handle all the common situations in a good way.</p>\n<p>In order to workaround issues, we added an utility that removes empty lines from the output, but it yielded some really weird results sometimes, this is now gone. Another tweak we've done is instead of indenting when <code>${</code> starts, we indent where the line that contains <code>${</code> starts.</p>\n<p>Let us know if you still have issues with how template literals output after this release!</p>\n<div class=\"highlight highlight-source-js\"><pre><span class=\"pl-c\"><span class=\"pl-c\">//</span> Before</span>\n<span class=\"pl-k\">const</span> <span class=\"pl-c1\">Bar</span> <span class=\"pl-k\">=</span> <span class=\"pl-smi\">styled</span>.<span class=\"pl-smi\">div</span><span class=\"pl-s\"><span class=\"pl-pds\">`</span></span>\n<span class=\"pl-s\">  color: <span class=\"pl-s1\"><span class=\"pl-pse\">${</span><span class=\"pl-smi\">props</span> <span class=\"pl-k\">=&gt;</span> (<span class=\"pl-smi\">props</span>.<span class=\"pl-smi\">highlight</span>.<span class=\"pl-c1\">length</span> <span class=\"pl-k\">&gt;</span> <span class=\"pl-c1\">0</span> <span class=\"pl-k\">?</span> <span class=\"pl-en\">palette</span>([</span></span>\n<span class=\"pl-s\"><span class=\"pl-s1\">                 <span class=\"pl-s\"><span class=\"pl-pds\">'</span>text<span class=\"pl-pds\">'</span></span>,</span></span>\n<span class=\"pl-s\"><span class=\"pl-s1\">                 <span class=\"pl-s\"><span class=\"pl-pds\">'</span>dark<span class=\"pl-pds\">'</span></span>,</span></span>\n<span class=\"pl-s\"><span class=\"pl-s1\">                 <span class=\"pl-s\"><span class=\"pl-pds\">'</span>tertiary<span class=\"pl-pds\">'</span></span></span></span>\n<span class=\"pl-s\"><span class=\"pl-s1\">               ])(props) <span class=\"pl-k\">:</span> <span class=\"pl-en\">palette</span>([</span></span>\n<span class=\"pl-s\"><span class=\"pl-s1\">                 <span class=\"pl-s\"><span class=\"pl-pds\">'</span>text<span class=\"pl-pds\">'</span></span>,</span></span>\n<span class=\"pl-s\"><span class=\"pl-s1\">                 <span class=\"pl-s\"><span class=\"pl-pds\">'</span>dark<span class=\"pl-pds\">'</span></span>,</span></span>\n<span class=\"pl-s\"><span class=\"pl-s1\">                 <span class=\"pl-s\"><span class=\"pl-pds\">'</span>primary<span class=\"pl-pds\">'</span></span></span></span>\n<span class=\"pl-s\"><span class=\"pl-s1\">               ])(props))<span class=\"pl-pse\">}</span></span> !important;</span>\n<span class=\"pl-s\"><span class=\"pl-pds\">`</span></span>\n\n<span class=\"pl-c\"><span class=\"pl-c\">//</span> After</span>\n<span class=\"pl-k\">const</span> <span class=\"pl-c1\">Bar</span> <span class=\"pl-k\">=</span> <span class=\"pl-smi\">styled</span>.<span class=\"pl-smi\">div</span><span class=\"pl-s\"><span class=\"pl-pds\">`</span></span>\n<span class=\"pl-s\">  color: <span class=\"pl-s1\"><span class=\"pl-pse\">${</span><span class=\"pl-smi\">props</span> <span class=\"pl-k\">=&gt;</span></span></span>\n<span class=\"pl-s\"><span class=\"pl-s1\">    <span class=\"pl-smi\">props</span>.<span class=\"pl-smi\">highlight</span>.<span class=\"pl-c1\">length</span> <span class=\"pl-k\">&gt;</span> <span class=\"pl-c1\">0</span></span></span>\n<span class=\"pl-s\"><span class=\"pl-s1\">      <span class=\"pl-k\">?</span> <span class=\"pl-en\">palette</span>([<span class=\"pl-s\"><span class=\"pl-pds\">\"</span>text<span class=\"pl-pds\">\"</span></span>, <span class=\"pl-s\"><span class=\"pl-pds\">\"</span>dark<span class=\"pl-pds\">\"</span></span>, <span class=\"pl-s\"><span class=\"pl-pds\">\"</span>tertiary<span class=\"pl-pds\">\"</span></span>])(props)</span></span>\n<span class=\"pl-s\"><span class=\"pl-s1\">      <span class=\"pl-k\">:</span> <span class=\"pl-en\">palette</span>([<span class=\"pl-s\"><span class=\"pl-pds\">\"</span>text<span class=\"pl-pds\">\"</span></span>, <span class=\"pl-s\"><span class=\"pl-pds\">\"</span>dark<span class=\"pl-pds\">\"</span></span>, <span class=\"pl-s\"><span class=\"pl-pds\">\"</span>primary<span class=\"pl-pds\">\"</span></span>])(props)<span class=\"pl-pse\">}</span></span> !important;</span>\n<span class=\"pl-s\"><span class=\"pl-pds\">`</span></span></pre></div>\n<h3>Use the same breaking rules for assignment and object values (<a href=\"https://urls.greenkeeper.io/prettier/prettier/pull/1721\" class=\"issue-link js-issue-link\" data-url=\"https://github.com/prettier/prettier/issues/1721\" data-id=\"231205147\" data-error-text=\"Failed to load issue title\" data-permission-text=\"Issue title is private\">#1721</a>)</h3>\n<p>We have a lot of fine-tuned logic for how to break things after assignment (eg <code>a = ...</code>). We are now using the same one for object values. This should help for multi-line boolean logic, or big conditionals. This is also a good example of how we can create a consistent printer.</p>\n<div class=\"highlight highlight-source-js\"><pre><span class=\"pl-c\"><span class=\"pl-c\">//</span> Before</span>\n<span class=\"pl-k\">const</span> <span class=\"pl-c1\">o</span> <span class=\"pl-k\">=</span> {\n  somethingThatsAReallyLongPropName<span class=\"pl-k\">:</span> <span class=\"pl-c1\">this</span>.<span class=\"pl-smi\">props</span>.<span class=\"pl-smi\">cardType</span> <span class=\"pl-k\">===</span>\n    <span class=\"pl-smi\">AwesomizerCardEnum</span>.<span class=\"pl-c1\">SEEFIRST</span>,\n};\n\n<span class=\"pl-c\"><span class=\"pl-c\">//</span> After</span>\n<span class=\"pl-k\">const</span> <span class=\"pl-c1\">o</span> <span class=\"pl-k\">=</span> {\n  somethingThatsAReallyLongPropName<span class=\"pl-k\">:</span>\n    <span class=\"pl-c1\">this</span>.<span class=\"pl-smi\">props</span>.<span class=\"pl-smi\">cardType</span> <span class=\"pl-k\">===</span> <span class=\"pl-smi\">AwesomizerCardEnum</span>.<span class=\"pl-c1\">SEEFIRST</span>,\n};</pre></div>\n<h3>Indent conditions inside of !() (<a href=\"https://urls.greenkeeper.io/prettier/prettier/pull/1731\" class=\"issue-link js-issue-link\" data-url=\"https://github.com/prettier/prettier/issues/1731\" data-id=\"231388966\" data-error-text=\"Failed to load issue title\" data-permission-text=\"Issue title is private\">#1731</a>)</h3>\n<p>There's been a steady stream of people complaining about the way it was rendered and was put on the list of things that are probably hard to do, will check later. It turned out to be super easy, so here you go!</p>\n<div class=\"highlight highlight-source-js\"><pre><span class=\"pl-c\"><span class=\"pl-c\">//</span> Before</span>\n<span class=\"pl-k\">const</span> <span class=\"pl-c1\">anyTestFailures</span> <span class=\"pl-k\">=</span> <span class=\"pl-k\">!</span>(<span class=\"pl-smi\">aggregatedResults</span>.<span class=\"pl-smi\">numFailedTests</span> <span class=\"pl-k\">===</span> <span class=\"pl-c1\">0</span> <span class=\"pl-k\">&amp;&amp;</span>\n  <span class=\"pl-smi\">aggregatedResults</span>.<span class=\"pl-smi\">numRuntimeErrorTestSuites</span> <span class=\"pl-k\">===</span> <span class=\"pl-c1\">0</span>);\n\n<span class=\"pl-c\"><span class=\"pl-c\">//</span> After</span>\n<span class=\"pl-k\">const</span> <span class=\"pl-c1\">anyTestFailures</span> <span class=\"pl-k\">=</span> <span class=\"pl-k\">!</span>(\n  <span class=\"pl-smi\">aggregatedResults</span>.<span class=\"pl-smi\">numFailedTests</span> <span class=\"pl-k\">===</span> <span class=\"pl-c1\">0</span> <span class=\"pl-k\">&amp;&amp;</span>\n  <span class=\"pl-smi\">aggregatedResults</span>.<span class=\"pl-smi\">numRuntimeErrorTestSuites</span> <span class=\"pl-k\">===</span> <span class=\"pl-c1\">0</span>\n);</pre></div>\n<h1>Formatting Fixes</h1>\n<h3>Put loop bodies on the same line when possible (<a href=\"https://urls.greenkeeper.io/prettier/prettier/pull/1498\" class=\"issue-link js-issue-link\" data-url=\"https://github.com/prettier/prettier/issues/1498\" data-id=\"226134607\" data-error-text=\"Failed to load issue title\" data-permission-text=\"Issue title is private\">#1498</a>)</h3>\n<p>We were already doing this for if statements, we should be consistent and also do it for loops.</p>\n<div class=\"highlight highlight-source-js\"><pre><span class=\"pl-c\"><span class=\"pl-c\">//</span> Before</span>\n<span class=\"pl-k\">for</span> (a <span class=\"pl-k\">in</span> b)\n  <span class=\"pl-k\">var</span> c <span class=\"pl-k\">=</span> {};\n\n<span class=\"pl-c\"><span class=\"pl-c\">//</span> After</span>\n<span class=\"pl-k\">for</span> (a <span class=\"pl-k\">in</span> b) <span class=\"pl-k\">var</span> c <span class=\"pl-k\">=</span> {};</pre></div>\n<h3>Fix empty line with flow union (<a href=\"https://urls.greenkeeper.io/prettier/prettier/pull/1511\" class=\"issue-link js-issue-link\" data-url=\"https://github.com/prettier/prettier/issues/1511\" data-id=\"226450467\" data-error-text=\"Failed to load issue title\" data-permission-text=\"Issue title is private\">#1511</a>) by <a href=\"https://urls.greenkeeper.io/existentialism\" class=\"user-mention\">@existentialism</a></h3>\n<p>We shouldn't indent things twice ;)</p>\n<div class=\"highlight highlight-source-js\"><pre><span class=\"pl-c\"><span class=\"pl-c\">//</span> Before</span>\ntype Foo <span class=\"pl-k\">=</span> <span class=\"pl-c1\">Promise</span><span class=\"pl-k\">&lt;</span>\n\n    <span class=\"pl-k\">|</span> { ok<span class=\"pl-k\">:</span> <span class=\"pl-c1\">true</span>, bar<span class=\"pl-k\">:</span> string, baz<span class=\"pl-k\">:</span> SomeOtherLongType }\n    <span class=\"pl-k\">|</span> { ok<span class=\"pl-k\">:</span> <span class=\"pl-c1\">false</span>, bar<span class=\"pl-k\">:</span> SomeOtherLongType }\n<span class=\"pl-k\">&gt;</span>;\n\n<span class=\"pl-c\"><span class=\"pl-c\">//</span> After</span>\ntype Foo <span class=\"pl-k\">=</span> <span class=\"pl-c1\">Promise</span><span class=\"pl-k\">&lt;</span>\n  { ok<span class=\"pl-k\">:</span> <span class=\"pl-c1\">true</span>, bar<span class=\"pl-k\">:</span> string, baz<span class=\"pl-k\">:</span> SomeOtherLongType } <span class=\"pl-k\">|</span> \n  { ok<span class=\"pl-k\">:</span> <span class=\"pl-c1\">false</span>, bar<span class=\"pl-k\">:</span> SomeOtherLongType }\n<span class=\"pl-k\">&gt;</span>;</pre></div>\n<h3>Do not put parens for single argument with end of line comment (<a href=\"https://urls.greenkeeper.io/prettier/prettier/pull/1518\" class=\"issue-link js-issue-link\" data-url=\"https://github.com/prettier/prettier/issues/1518\" data-id=\"226692591\" data-error-text=\"Failed to load issue title\" data-permission-text=\"Issue title is private\">#1518</a>)</h3>\n<p>The detection code for whether an arrow function should be written without parenthesis just checked if there was a comment, but instead we only want comments that are inline like <code>(/* comment */ num)</code>, not end of line comments.</p>\n<div class=\"highlight highlight-source-js\"><pre><span class=\"pl-c\"><span class=\"pl-c\">//</span> Before</span>\n<span class=\"pl-c1\">KEYPAD_NUMBERS</span>.<span class=\"pl-en\">map</span>((<span class=\"pl-smi\">num</span>) <span class=\"pl-k\">=&gt;</span> ( <span class=\"pl-c\"><span class=\"pl-c\">//</span> Buttons 0-9</span>\n  <span class=\"pl-k\">&lt;</span>div <span class=\"pl-k\">/</span><span class=\"pl-k\">&gt;</span>\n));\n\n<span class=\"pl-c1\">KEYPAD_NUMBERS</span>.<span class=\"pl-en\">map</span>(<span class=\"pl-smi\">num</span> <span class=\"pl-k\">=&gt;</span> ( <span class=\"pl-c\"><span class=\"pl-c\">//</span> Buttons 0-9</span>\n  <span class=\"pl-k\">&lt;</span>div <span class=\"pl-k\">/</span><span class=\"pl-k\">&gt;</span>\n));</pre></div>\n<h3>Do not indent nested ternaries (<a href=\"https://urls.greenkeeper.io/prettier/prettier/pull/1822\" class=\"issue-link js-issue-link\" data-url=\"https://github.com/prettier/prettier/issues/1822\" data-id=\"232320155\" data-error-text=\"Failed to load issue title\" data-permission-text=\"Issue title is private\">#1822</a>)</h3>\n<p>This avoids making it seems like it is indented by 4 characters instead of two. The downside is that if the condition is multi-line it's not going to be properly aligned, but I feel it's a better trade-offs. If you are doing nested ternaries, you usually have small conditions.</p>\n<div class=\"highlight highlight-source-js\"><pre><span class=\"pl-c\"><span class=\"pl-c\">//</span> Before</span>\naaaaaaaaaaaaaaa\n  <span class=\"pl-k\">?</span> bbbbbbbbbbbbbbbbbb\n  <span class=\"pl-k\">:</span> ccccccccccccccc\n      <span class=\"pl-k\">?</span> ddddddddddddddd\n      <span class=\"pl-k\">:</span> eeeeeeeeeeeeeee <span class=\"pl-k\">?</span> fffffffffffffff <span class=\"pl-k\">:</span> gggggggggggggggg;\n\n<span class=\"pl-c\"><span class=\"pl-c\">//</span> After</span>\naaaaaaaaaaaaaaa\n  <span class=\"pl-k\">?</span> bbbbbbbbbbbbbbbbbb\n  <span class=\"pl-k\">:</span> ccccccccccccccc\n    <span class=\"pl-k\">?</span> ddddddddddddddd\n    <span class=\"pl-k\">:</span> eeeeeeeeeeeeeee <span class=\"pl-k\">?</span> fffffffffffffff <span class=\"pl-k\">:</span> gggggggggggggggg;</pre></div>\n<h3>Inline chained conditionals inside of jsx attribute (<a href=\"https://urls.greenkeeper.io/prettier/prettier/pull/1519\" class=\"issue-link js-issue-link\" data-url=\"https://github.com/prettier/prettier/issues/1519\" data-id=\"226695044\" data-error-text=\"Failed to load issue title\" data-permission-text=\"Issue title is private\">#1519</a>)</h3>\n<p>We don't need to use the indentation to disambiguate another block as nothing can come after.</p>\n<div class=\"highlight highlight-source-js\"><pre><span class=\"pl-c\"><span class=\"pl-c\">//</span> Before</span>\n<span class=\"pl-k\">&lt;</span>div\n  src<span class=\"pl-k\">=</span>{\n    <span class=\"pl-k\">!</span>isEnabled <span class=\"pl-k\">&amp;&amp;</span>\n      diffUpdateMessageInput <span class=\"pl-k\">!=</span> <span class=\"pl-c1\">null</span> <span class=\"pl-k\">&amp;&amp;</span>\n      <span class=\"pl-c1\">this</span>.<span class=\"pl-smi\">state</span>.<span class=\"pl-smi\">isUpdateMessageEmpty</span>\n  }\n<span class=\"pl-k\">/</span><span class=\"pl-k\">&gt;</span>;\n\n<span class=\"pl-c\"><span class=\"pl-c\">//</span> After</span>\n<span class=\"pl-k\">&lt;</span>div\n  src<span class=\"pl-k\">=</span>{\n    <span class=\"pl-k\">!</span>isEnabled <span class=\"pl-k\">&amp;&amp;</span>\n    diffUpdateMessageInput <span class=\"pl-k\">!=</span> <span class=\"pl-c1\">null</span> <span class=\"pl-k\">&amp;&amp;</span>\n    <span class=\"pl-c1\">this</span>.<span class=\"pl-smi\">state</span>.<span class=\"pl-smi\">isUpdateMessageEmpty</span>\n  }\n<span class=\"pl-k\">/</span><span class=\"pl-k\">&gt;</span>;</pre></div>\n<h3>Unescape unnecessarily escaped characters in strings (<a href=\"https://urls.greenkeeper.io/prettier/prettier/pull/1575\" class=\"issue-link js-issue-link\" data-url=\"https://github.com/prettier/prettier/issues/1575\" data-id=\"227680536\" data-error-text=\"Failed to load issue title\" data-permission-text=\"Issue title is private\">#1575</a>) by <a href=\"https://urls.greenkeeper.io/josephfrazier\" class=\"user-mention\">@josephfrazier</a></h3>\n<p>We are already trying to cleanup strings in various ways, this is another small addition that's going to remove <code>\\</code> that are not needed.</p>\n<div class=\"highlight highlight-source-js\"><pre><span class=\"pl-c\"><span class=\"pl-c\">//</span> Before</span>\na <span class=\"pl-k\">=</span> <span class=\"pl-s\"><span class=\"pl-pds\">'</span>hol<span class=\"pl-cce\">\\a</span><span class=\"pl-pds\">'</span></span>;\n\n<span class=\"pl-c\"><span class=\"pl-c\">//</span> After</span>\na <span class=\"pl-k\">=</span> <span class=\"pl-s\"><span class=\"pl-pds\">'</span>hola<span class=\"pl-pds\">'</span></span>;</pre></div>\n<h3>Fix boolean for empty objects (<a href=\"https://urls.greenkeeper.io/prettier/prettier/pull/1590\" class=\"issue-link js-issue-link\" data-url=\"https://github.com/prettier/prettier/issues/1590\" data-id=\"228113629\" data-error-text=\"Failed to load issue title\" data-permission-text=\"Issue title is private\">#1590</a>) by <a href=\"https://urls.greenkeeper.io/dmitrika\" class=\"user-mention\">@dmitrika</a></h3>\n<p>We want to inline objects inside of a boolean expression as it looks weird to have <code>{</code> on its own line. But it turns out that it leads to weird behaviors for empty objects. So we keep them on their own line if they are empty.</p>\n<div class=\"highlight highlight-source-js\"><pre><span class=\"pl-k\">const</span> <span class=\"pl-c1\">x</span> <span class=\"pl-k\">=</span> firstItemWithAVeryLongNameThatKeepsGoing <span class=\"pl-k\">||</span>\nsecondItemWithALongNameAsWell <span class=\"pl-k\">||</span> {};\n\n<span class=\"pl-c\"><span class=\"pl-c\">//</span> After</span>\n<span class=\"pl-k\">const</span> <span class=\"pl-c1\">x</span> <span class=\"pl-k\">=</span> \n  firstItemWithAVeryLongNameThatKeepsGoing <span class=\"pl-k\">||</span>\n  secondItemWithALongNameAsWell <span class=\"pl-k\">||</span> \n  {};</pre></div>\n<h3>Remove Parens from SequenceExpressions in ForStatements (<a href=\"https://urls.greenkeeper.io/prettier/prettier/pull/1597\" class=\"issue-link js-issue-link\" data-url=\"https://github.com/prettier/prettier/issues/1597\" data-id=\"228328906\" data-error-text=\"Failed to load issue title\" data-permission-text=\"Issue title is private\">#1597</a>) by <a href=\"https://urls.greenkeeper.io/k15a\" class=\"user-mention\">@k15a</a></h3>\n<p>It is common to assign multiple values inside of a for loop, now we don't add parenthesis anymore.</p>\n<div class=\"highlight highlight-source-js\"><pre><span class=\"pl-c\"><span class=\"pl-c\">//</span> Before</span>\n<span class=\"pl-k\">for</span> ((i <span class=\"pl-k\">=</span> <span class=\"pl-c1\">0</span>), (len <span class=\"pl-k\">=</span> <span class=\"pl-smi\">arr</span>.<span class=\"pl-c1\">length</span>); i <span class=\"pl-k\">&lt;</span> len; i<span class=\"pl-k\">++</span>) {\n\n<span class=\"pl-c\"><span class=\"pl-c\">//</span> After</span>\n<span class=\"pl-k\">for</span> (i <span class=\"pl-k\">=</span> <span class=\"pl-c1\">0</span>, len <span class=\"pl-k\">=</span> <span class=\"pl-smi\">arr</span>.<span class=\"pl-c1\">length</span>; i <span class=\"pl-k\">&lt;</span> len; i<span class=\"pl-k\">++</span>) {</pre></div>\n<h3>Do not inline arrow when argument has a leading comment (<a href=\"https://urls.greenkeeper.io/prettier/prettier/pull/1660\" class=\"issue-link js-issue-link\" data-url=\"https://github.com/prettier/prettier/issues/1660\" data-id=\"230271523\" data-error-text=\"Failed to load issue title\" data-permission-text=\"Issue title is private\">#1660</a>)</h3>\n<p>If you put block comments inside of arrow functions, we no longer mess everything up!</p>\n<div class=\"highlight highlight-source-js\"><pre><span class=\"pl-c\"><span class=\"pl-c\">//</span> Before</span>\n<span class=\"pl-k\">export</span> <span class=\"pl-k\">const</span> <span class=\"pl-c1\">bem</span> <span class=\"pl-k\">=</span> <span class=\"pl-smi\">block</span> <span class=\"pl-k\">=&gt;</span> <span class=\"pl-c\">/**</span>\n<span class=\"pl-c\">   * <span class=\"pl-k\">@param</span> <span class=\"pl-en\">{String}</span> <span class=\"pl-smi\">[element]</span> - the BEM Element within that block; if undefined, selects the block itself.</span>\n<span class=\"pl-c\">   */</span>\n<span class=\"pl-smi\">element</span> <span class=\"pl-k\">=&gt;</span> <span class=\"pl-c\">/**</span>\n<span class=\"pl-c\">     * <span class=\"pl-k\">@param</span> <span class=\"pl-en\">{?String}</span> <span class=\"pl-smi\">[modifier]</span> - the BEM Modifier for the Block or Element; if undefined, selects the Block or Element unmodified.</span>\n<span class=\"pl-c\">     */</span>\n<span class=\"pl-smi\">modifier</span> <span class=\"pl-k\">=&gt;</span>\n\n<span class=\"pl-c\"><span class=\"pl-c\">//</span> After</span>\n<span class=\"pl-k\">export</span> <span class=\"pl-k\">const</span> <span class=\"pl-c1\">bem</span> <span class=\"pl-k\">=</span> <span class=\"pl-smi\">block</span> <span class=\"pl-k\">=&gt;</span>\n  <span class=\"pl-c\">/**</span>\n<span class=\"pl-c\">   * <span class=\"pl-k\">@param</span> <span class=\"pl-en\">{String}</span> <span class=\"pl-smi\">[element]</span> - the BEM Element within that block; if undefined, selects the block itself.</span>\n<span class=\"pl-c\">   */</span>\n  <span class=\"pl-smi\">element</span> <span class=\"pl-k\">=&gt;</span>\n    <span class=\"pl-c\">/**</span>\n<span class=\"pl-c\">     * <span class=\"pl-k\">@param</span> <span class=\"pl-en\">{?String}</span> <span class=\"pl-smi\">[modifier]</span> - the BEM Modifier for the Block or Element; if undefined, selects the Block or Element unmodified.</span>\n<span class=\"pl-c\">     */</span>\n    <span class=\"pl-smi\">modifier</span> <span class=\"pl-k\">=&gt;</span></pre></div>\n<h3>Fix last comments of imports (<a href=\"https://urls.greenkeeper.io/prettier/prettier/pull/1677\" class=\"issue-link js-issue-link\" data-url=\"https://github.com/prettier/prettier/issues/1677\" data-id=\"230800656\" data-error-text=\"Failed to load issue title\" data-permission-text=\"Issue title is private\">#1677</a>)</h3>\n<p>Another place where we have to do special logic for comments!</p>\n<div class=\"highlight highlight-source-js\"><pre><span class=\"pl-c\"><span class=\"pl-c\">//</span> Before</span>\n<span class=\"pl-k\">import</span> {\n  <span class=\"pl-smi\">ExecutionResult</span>,\n  <span class=\"pl-smi\">DocumentNode</span>,\n  <span class=\"pl-c\">/* tslint:disable */</span>\n  <span class=\"pl-smi\">SelectionSetNode</span>,\n} <span class=\"pl-c\">/* tslint:enable */</span> <span class=\"pl-k\">from</span> <span class=\"pl-s\"><span class=\"pl-pds\">'</span>graphql<span class=\"pl-pds\">'</span></span>;\n\n<span class=\"pl-c\"><span class=\"pl-c\">//</span> After</span>\n<span class=\"pl-k\">import</span> {\n  <span class=\"pl-smi\">DocumentNode</span>,\n  <span class=\"pl-c\">/* tslint:disable */</span>\n  <span class=\"pl-smi\">SelectionSetNode</span>,\n  <span class=\"pl-c\">/* tslint:enable */</span>\n} <span class=\"pl-k\">from</span> <span class=\"pl-s\"><span class=\"pl-pds\">'</span>graphql<span class=\"pl-pds\">'</span></span>;</pre></div>\n<h3>Handle comments in member chain (<a href=\"https://urls.greenkeeper.io/prettier/prettier/pull/1686\" class=\"issue-link js-issue-link\" data-url=\"https://github.com/prettier/prettier/issues/1686\" data-id=\"230838545\" data-error-text=\"Failed to load issue title\" data-permission-text=\"Issue title is private\">#1686</a>, <a href=\"https://urls.greenkeeper.io/prettier/prettier/pull/1691\" class=\"issue-link js-issue-link\" data-url=\"https://github.com/prettier/prettier/issues/1691\" data-id=\"230878082\" data-error-text=\"Failed to load issue title\" data-permission-text=\"Issue title is private\">#1691</a>)</h3>\n<p>We handled some placements before and kept adding places where they could appear, now we switch to a more general approach. Hopefully those issues shouldn't crop up in the future anymore.</p>\n<div class=\"highlight highlight-source-js\"><pre><span class=\"pl-c\"><span class=\"pl-c\">//</span> Before</span>\n<span class=\"pl-k\">const</span> <span class=\"pl-c1\">configModel</span> <span class=\"pl-k\">=</span> <span class=\"pl-c1\">this</span>.<span class=\"pl-smi\">baseConfigurationService</span>.<span class=\"pl-en\">getCache</span>().<span class=\"pl-smi\">consolidated</span> <span class=\"pl-c\"><span class=\"pl-c\">//</span> global/default values (do NOT modify)</span>\n  .<span class=\"pl-en\">merge</span>(<span class=\"pl-c1\">this</span>.<span class=\"pl-smi\">cachedWorkspaceConfig</span>);\n\n<span class=\"pl-c\"><span class=\"pl-c\">//</span> After</span>\n<span class=\"pl-k\">const</span> <span class=\"pl-c1\">configModel</span> <span class=\"pl-k\">=</span> <span class=\"pl-c1\">this</span>.<span class=\"pl-smi\">baseConfigurationService</span>\n  .<span class=\"pl-en\">getCache</span>()\n  .<span class=\"pl-smi\">consolidated</span> <span class=\"pl-c\"><span class=\"pl-c\">//</span> global/default values (do NOT modify)</span>\n  .<span class=\"pl-en\">merge</span>(<span class=\"pl-c1\">this</span>.<span class=\"pl-smi\">cachedWorkspaceConfig</span>);</pre></div>\n<h3>Use expandLast for nested arrow functions (<a href=\"https://urls.greenkeeper.io/prettier/prettier/pull/1720\" class=\"issue-link js-issue-link\" data-url=\"https://github.com/prettier/prettier/issues/1720\" data-id=\"231202215\" data-error-text=\"Failed to load issue title\" data-permission-text=\"Issue title is private\">#1720</a>)</h3>\n<div class=\"highlight highlight-source-js\"><pre><span class=\"pl-c\"><span class=\"pl-c\">//</span> Before</span>\n<span class=\"pl-en\">f</span>(<span class=\"pl-smi\">action</span> <span class=\"pl-k\">=&gt;</span> <span class=\"pl-smi\">next</span> <span class=\"pl-k\">=&gt;</span>\n    <span class=\"pl-en\">next</span>(action));\n\n<span class=\"pl-c\"><span class=\"pl-c\">//</span> After</span>\n<span class=\"pl-en\">f</span>(<span class=\"pl-smi\">action</span> <span class=\"pl-k\">=&gt;</span> <span class=\"pl-smi\">next</span> <span class=\"pl-k\">=&gt;</span>\n    <span class=\"pl-en\">next</span>(action),\n);</pre></div>\n<h3>Put JSX comments inside of the parenthesis (<a href=\"https://urls.greenkeeper.io/prettier/prettier/pull/1712\" class=\"issue-link js-issue-link\" data-url=\"https://github.com/prettier/prettier/issues/1712\" data-id=\"231145981\" data-error-text=\"Failed to load issue title\" data-permission-text=\"Issue title is private\">#1712</a>)</h3>\n<p>This mostly affects Facebook engineers where we automatically add <code>$FlowFixMe</code> when pushing a new version of flow. Now it no longer messes up those comments.</p>\n<div class=\"highlight highlight-source-js\"><pre><span class=\"pl-c\"><span class=\"pl-c\">//</span> Before</span>\n<span class=\"pl-k\">const</span> <span class=\"pl-c1\">aDiv</span> <span class=\"pl-k\">=</span> <span class=\"pl-c\">/* $FlowFixMe */</span>\n(\n  <span class=\"pl-k\">&lt;</span>div className<span class=\"pl-k\">=</span><span class=\"pl-s\"><span class=\"pl-pds\">\"</span>foo<span class=\"pl-pds\">\"</span></span><span class=\"pl-k\">&gt;</span>\n    Foo bar\n  <span class=\"pl-k\">&lt;</span><span class=\"pl-k\">/</span>div<span class=\"pl-k\">&gt;</span>\n);\n\n<span class=\"pl-c\"><span class=\"pl-c\">//</span> After</span>\n<span class=\"pl-k\">const</span> <span class=\"pl-c1\">aDiv</span> <span class=\"pl-k\">=</span> (\n  <span class=\"pl-c\">/* $FlowFixMe */</span>\n  <span class=\"pl-k\">&lt;</span>div className<span class=\"pl-k\">=</span><span class=\"pl-s\"><span class=\"pl-pds\">\"</span>foo<span class=\"pl-pds\">\"</span></span><span class=\"pl-k\">&gt;</span>\n    Foo bar\n  <span class=\"pl-k\">&lt;</span><span class=\"pl-k\">/</span>div<span class=\"pl-k\">&gt;</span>\n);</pre></div>\n<h3>Force \\n for multiple variable declarations (<a href=\"https://urls.greenkeeper.io/prettier/prettier/pull/1723\" class=\"issue-link js-issue-link\" data-url=\"https://github.com/prettier/prettier/issues/1723\" data-id=\"231217011\" data-error-text=\"Failed to load issue title\" data-permission-text=\"Issue title is private\">#1723</a>)</h3>\n<p>This one has been very often requested. We used to only break multiple variable declarations if the line was &gt; 80 columns. Now we do it regardless if there's at least one with an assignment.</p>\n<div class=\"highlight highlight-source-js\"><pre><span class=\"pl-c\"><span class=\"pl-c\">//</span> Before</span>\n<span class=\"pl-k\">var</span> numberValue1 <span class=\"pl-k\">=</span> <span class=\"pl-c1\">1</span>, numberValue2 <span class=\"pl-k\">=</span> <span class=\"pl-c1\">2</span>;\n\n<span class=\"pl-c\"><span class=\"pl-c\">//</span> After</span>\n<span class=\"pl-k\">var</span> numberValue1 <span class=\"pl-k\">=</span> <span class=\"pl-c1\">1</span>,\n numberValue2 <span class=\"pl-k\">=</span> <span class=\"pl-c1\">2</span>;</pre></div>\n<h3>Inline | null and | void (<a href=\"https://urls.greenkeeper.io/prettier/prettier/pull/1734\" class=\"issue-link js-issue-link\" data-url=\"https://github.com/prettier/prettier/issues/1734\" data-id=\"231445718\" data-error-text=\"Failed to load issue title\" data-permission-text=\"Issue title is private\">#1734</a>)</h3>\n<p>The expanded version of flow union looks good when they are many objects but if it's used for nullability, the it looks very weird. We're now inlining <code>| null</code> and <code>| void</code>.</p>\n<div class=\"highlight highlight-source-js\"><pre><span class=\"pl-c\"><span class=\"pl-c\">//</span> Before</span>\n<span class=\"pl-k\">interface</span> RelayProps {\n  articles<span class=\"pl-k\">:</span>\n    <span class=\"pl-k\">|</span> <span class=\"pl-c1\">Array</span><span class=\"pl-k\">&lt;</span>\n      <span class=\"pl-k\">|</span> {\n        __id<span class=\"pl-k\">:</span> string,\n      }\n      <span class=\"pl-k\">|</span> <span class=\"pl-c1\">null</span>\n    <span class=\"pl-k\">&gt;</span>\n    <span class=\"pl-k\">|</span> <span class=\"pl-c1\">null</span>\n}\n\n<span class=\"pl-c\"><span class=\"pl-c\">//</span> After</span>\n<span class=\"pl-k\">interface</span> RelayProps {\n  articles<span class=\"pl-k\">:</span> <span class=\"pl-c1\">Array</span><span class=\"pl-k\">&lt;</span>{\n    __id<span class=\"pl-k\">:</span> string,\n  } <span class=\"pl-k\">|</span> <span class=\"pl-c1\">null</span><span class=\"pl-k\">&gt;</span> <span class=\"pl-k\">|</span> <span class=\"pl-c1\">null</span>,\n}</pre></div>\n<h3>Break on implements instead of extends (<a href=\"https://urls.greenkeeper.io/prettier/prettier/pull/1730\" class=\"issue-link js-issue-link\" data-url=\"https://github.com/prettier/prettier/issues/1730\" data-id=\"231383780\" data-error-text=\"Failed to load issue title\" data-permission-text=\"Issue title is private\">#1730</a>)</h3>\n<p>We no longer break on <code>extends</code>. This should make classes with extends that can break look less wonky.</p>\n<div class=\"highlight highlight-source-js\"><pre><span class=\"pl-c\"><span class=\"pl-c\">//</span> Before</span>\n<span class=\"pl-k\">class</span> <span class=\"pl-en\">MyContractSelectionWidget</span>\n  <span class=\"pl-k\">extends</span> <span class=\"pl-smi\">React</span>.<span class=\"pl-smi\">Component</span><span class=\"pl-k\">&lt;</span>\n    <span class=\"pl-k\">void</span>,\n    MyContractSelectionWidgetPropsType,\n    <span class=\"pl-k\">void</span>\n  <span class=\"pl-k\">&gt;</span> {\n  <span class=\"pl-en\">method</span>() {}\n}\n\n<span class=\"pl-c\"><span class=\"pl-c\">//</span> After</span>\n<span class=\"pl-k\">class</span> <span class=\"pl-en\">MyContractSelectionWidget</span> <span class=\"pl-k\">extends</span> <span class=\"pl-e\">React</span>.<span class=\"pl-smi\">Component</span><span class=\"pl-k\">&lt;</span>\n  <span class=\"pl-k\">void</span>,\n  MyContractSelectionWidgetPropsType,\n  <span class=\"pl-k\">void</span>\n<span class=\"pl-k\">&gt;</span> {\n  <span class=\"pl-en\">method</span>() {}\n}</pre></div>\n<h3>Inline single import (<a href=\"https://urls.greenkeeper.io/prettier/prettier/pull/1729\" class=\"issue-link js-issue-link\" data-url=\"https://github.com/prettier/prettier/issues/1729\" data-id=\"231378820\" data-error-text=\"Failed to load issue title\" data-permission-text=\"Issue title is private\">#1729</a>)</h3>\n<p>The same way we don't break long <code>require</code> calls, we no longer break <code>import</code> statements if there is only a single thing being imported.</p>\n<div class=\"highlight highlight-source-js\"><pre><span class=\"pl-c\"><span class=\"pl-c\">//</span> Before</span>\n<span class=\"pl-k\">import</span> somethingSuperLongsomethingSuperLong\n  from <span class=\"pl-s\"><span class=\"pl-pds\">\"</span>somethingSuperLongsomethingSuperLongsomethingSuperLong<span class=\"pl-pds\">\"</span></span>;\n\n<span class=\"pl-c\"><span class=\"pl-c\">//</span> After</span>\n<span class=\"pl-k\">import</span> <span class=\"pl-smi\">somethingSuperLongsomethingSuperLong</span> <span class=\"pl-k\">from</span> <span class=\"pl-s\"><span class=\"pl-pds\">\"</span>somethingSuperLongsomethingSuperLongsomethingSuperLong<span class=\"pl-pds\">\"</span></span>;</pre></div>\n<h3>Add the ability for SequenceExpression to break (<a href=\"https://urls.greenkeeper.io/prettier/prettier/pull/1749\" class=\"issue-link js-issue-link\" data-url=\"https://github.com/prettier/prettier/issues/1749\" data-id=\"231715463\" data-error-text=\"Failed to load issue title\" data-permission-text=\"Issue title is private\">#1749</a>)</h3>\n<p>Did you know that if none of your code were statements, you could use <code>()</code> instead of <code>{}</code> and <code>,</code> instead of <code>;</code>? Now you do. Some people exploit this fact when returning things from arrow functions. This is not recommended but it's easy to support in prettier so might as well ¯_(ツ)_/¯</p>\n<div class=\"highlight highlight-source-js\"><pre><span class=\"pl-c\"><span class=\"pl-c\">//</span> Before</span>\n<span class=\"pl-k\">const</span> <span class=\"pl-c1\">f</span> <span class=\"pl-k\">=</span> (<span class=\"pl-smi\">argument1</span>, <span class=\"pl-smi\">argument2</span>, <span class=\"pl-smi\">argument3</span>) <span class=\"pl-k\">=&gt;</span>\n  (<span class=\"pl-en\">doSomethingWithArgument</span>(argument1), <span class=\"pl-en\">doSomethingWithArgument</span>(\n    argument2\n  ), argument1);\n\n<span class=\"pl-c\"><span class=\"pl-c\">//</span> After</span>\n<span class=\"pl-k\">const</span> <span class=\"pl-c1\">f</span> <span class=\"pl-k\">=</span> (<span class=\"pl-smi\">argument1</span>, <span class=\"pl-smi\">argument2</span>, <span class=\"pl-smi\">argument3</span>) <span class=\"pl-k\">=&gt;</span> (\n  <span class=\"pl-en\">doSomethingWithArgument</span>(argument1),\n  <span class=\"pl-en\">doSomethingWithArgument</span>(argument2),\n  argument1\n);</pre></div>\n<h3>Don't force line break in empty loop bodies (<a href=\"https://urls.greenkeeper.io/prettier/prettier/pull/1815\" class=\"issue-link js-issue-link\" data-url=\"https://github.com/prettier/prettier/issues/1815\" data-id=\"232141847\" data-error-text=\"Failed to load issue title\" data-permission-text=\"Issue title is private\">#1815</a>)</h3>\n<p>Loops with empty body no longer have their <code>{}</code> split into two lines.</p>\n<div class=\"highlight highlight-source-js\"><pre><span class=\"pl-c\"><span class=\"pl-c\">//</span> Before</span>\n<span class=\"pl-k\">while</span> (<span class=\"pl-c1\">true</span>) {\n}\n\n<span class=\"pl-c\"><span class=\"pl-c\">//</span> After</span>\n<span class=\"pl-k\">while</span> (<span class=\"pl-c1\">true</span>) {}</pre></div>\n<h3>Preserve empty lines between switch cases with comments (<a href=\"https://urls.greenkeeper.io/prettier/prettier/issues/1708\" class=\"issue-link js-issue-link\" data-url=\"https://github.com/prettier/prettier/issues/1708\" data-id=\"231119415\" data-error-text=\"Failed to load issue title\" data-permission-text=\"Issue title is private\">#1708</a>)</h3>\n<div class=\"highlight highlight-source-js\"><pre><span class=\"pl-c\"><span class=\"pl-c\">//</span> Before</span>\n<span class=\"pl-k\">switch</span> (<span class=\"pl-c1\">true</span>) {\n  <span class=\"pl-k\">case</span> <span class=\"pl-c1\">true</span>:\n  <span class=\"pl-c\"><span class=\"pl-c\">//</span> Good luck getting here</span>\n  <span class=\"pl-k\">case</span> <span class=\"pl-c1\">false</span>:\n}\n\n<span class=\"pl-c\"><span class=\"pl-c\">//</span> After</span>\n<span class=\"pl-k\">switch</span> (<span class=\"pl-c1\">true</span>) {\n  <span class=\"pl-k\">case</span> <span class=\"pl-c1\">true</span>:\n    \n  <span class=\"pl-c\"><span class=\"pl-c\">//</span> Good luck getting here</span>\n  <span class=\"pl-k\">case</span> <span class=\"pl-c1\">false</span>:\n}</pre></div>\n<h1>Correctness</h1>\n<h3>Remove ast-types (<a href=\"https://urls.greenkeeper.io/prettier/prettier/pull/1743\" class=\"issue-link js-issue-link\" data-url=\"https://github.com/prettier/prettier/issues/1743\" data-id=\"231690996\" data-error-text=\"Failed to load issue title\" data-permission-text=\"Issue title is private\">#1743</a>, <a href=\"https://urls.greenkeeper.io/prettier/prettier/pull/1744\" class=\"issue-link js-issue-link\" data-url=\"https://github.com/prettier/prettier/issues/1744\" data-id=\"231697387\" data-error-text=\"Failed to load issue title\" data-permission-text=\"Issue title is private\">#1744</a>, <a href=\"https://urls.greenkeeper.io/prettier/prettier/pull/1745\" class=\"issue-link js-issue-link\" data-url=\"https://github.com/prettier/prettier/issues/1745\" data-id=\"231705768\" data-error-text=\"Failed to load issue title\" data-permission-text=\"Issue title is private\">#1745</a>, <a href=\"https://urls.greenkeeper.io/prettier/prettier/pull/1746\" class=\"issue-link js-issue-link\" data-url=\"https://github.com/prettier/prettier/issues/1746\" data-id=\"231707725\" data-error-text=\"Failed to load issue title\" data-permission-text=\"Issue title is private\">#1746</a>, <a href=\"https://urls.greenkeeper.io/prettier/prettier/pull/1747\" class=\"issue-link js-issue-link\" data-url=\"https://github.com/prettier/prettier/issues/1747\" data-id=\"231708206\" data-error-text=\"Failed to load issue title\" data-permission-text=\"Issue title is private\">#1747</a>)</h3>\n<p>We used to find where to put comments by traversing the AST using the definition from ast-types. This occasionally caused issues when some field wasn't declared, we wouldn't find the node and either print comments in an incorrect location or throw an error. It turns out that we don't need to keep this mapping and can just traverse the objects and if a node has a <code>type</code> field, then it's a node.</p>\n<div class=\"highlight highlight-source-js\"><pre><span class=\"pl-c\"><span class=\"pl-c\">//</span> Before</span>\n<span class=\"pl-c1\">Error</span><span class=\"pl-k\">:</span> did not recognize object <span class=\"pl-k\">of</span> type <span class=\"pl-s\"><span class=\"pl-pds\">\"</span>ObjectTypeSpreadProperty<span class=\"pl-pds\">\"</span></span>\n\n<span class=\"pl-c\"><span class=\"pl-c\">//</span> After</span>\ntype <span class=\"pl-c1\">X</span> <span class=\"pl-k\">=</span> {<span class=\"pl-k\">...</span>Y<span class=\"pl-c\">/**/</span>};\ntype <span class=\"pl-c1\">X</span> <span class=\"pl-k\">=</span> {<span class=\"pl-c\">/**/</span><span class=\"pl-k\">...</span>Y};</pre></div>\n<h3>Preserve unusual unicode whitespace (<a href=\"https://urls.greenkeeper.io/prettier/prettier/pull/1658\" class=\"issue-link js-issue-link\" data-url=\"https://github.com/prettier/prettier/issues/1658\" data-id=\"230249109\" data-error-text=\"Failed to load issue title\" data-permission-text=\"Issue title is private\">#1658</a>, <a href=\"https://urls.greenkeeper.io/prettier/prettier/pull/1165\" class=\"issue-link js-issue-link\" data-url=\"https://github.com/prettier/prettier/issues/1165\" data-id=\"220426089\" data-error-text=\"Failed to load issue title\" data-permission-text=\"Issue title is private\">#1165</a>) by <a href=\"https://urls.greenkeeper.io/karl\" class=\"user-mention\">@karl</a> and <a href=\"https://urls.greenkeeper.io/yamafaktory\" class=\"user-mention\">@yamafaktory</a></h3>\n<p>If you were adding invisible characters inside of JSX text, we would replace them by regular spaces. I don't know why anyone would ever want to do that, but now we print it back as is!</p>\n<h3>Don't let trailing template literal comments escape (<a href=\"https://urls.greenkeeper.io/prettier/prettier/pull/1580\" class=\"issue-link js-issue-link\" data-url=\"https://github.com/prettier/prettier/issues/1580\" data-id=\"227847827\" data-error-text=\"Failed to load issue title\" data-permission-text=\"Issue title is private\">#1580</a>, <a href=\"https://urls.greenkeeper.io/prettier/prettier/pull/1713\" class=\"issue-link js-issue-link\" data-url=\"https://github.com/prettier/prettier/issues/1713\" data-id=\"231152442\" data-error-text=\"Failed to load issue title\" data-permission-text=\"Issue title is private\">#1713</a>, <a href=\"https://urls.greenkeeper.io/prettier/prettier/pull/1598\" class=\"issue-link js-issue-link\" data-url=\"https://github.com/prettier/prettier/issues/1598\" data-id=\"228344358\" data-error-text=\"Failed to load issue title\" data-permission-text=\"Issue title is private\">#1598</a>, <a href=\"https://urls.greenkeeper.io/prettier/prettier/pull/1713\" class=\"issue-link js-issue-link\" data-url=\"https://github.com/prettier/prettier/issues/1713\" data-id=\"231152442\" data-error-text=\"Failed to load issue title\" data-permission-text=\"Issue title is private\">#1713</a>) by <a href=\"https://urls.greenkeeper.io/josephfrazier\" class=\"user-mention\">@josephfrazier</a> and <a href=\"https://urls.greenkeeper.io/k15a\" class=\"user-mention\">@k15a</a></h3>\n<p>We used to have some pretty complicated (and not working well) code to handle comments inside of template literals. We introduced a really nice solution for JSX <code>{}</code> expressions. The idea is to introduce a boundary before the end of the <code>}</code> and if we still have unprinted comments, then flush them all at once, put a \\n and print the <code>}</code>. We are now using this logic for template literals :)</p>\n<div class=\"highlight highlight-source-js\"><pre><span class=\"pl-c\"><span class=\"pl-c\">//</span> Before</span>\n<span class=\"pl-s\"><span class=\"pl-pds\">`</span><span class=\"pl-s1\"><span class=\"pl-pse\">${</span><span class=\"pl-c1\">0</span><span class=\"pl-pse\">}</span></span> // comment<span class=\"pl-pds\">`</span></span>;\n\n<span class=\"pl-c\"><span class=\"pl-c\">//</span> After</span>\n<span class=\"pl-s\"><span class=\"pl-pds\">`</span><span class=\"pl-s1\"><span class=\"pl-pse\">${</span></span></span>\n<span class=\"pl-s\"><span class=\"pl-s1\"><span class=\"pl-c1\">0</span></span></span>\n<span class=\"pl-s\"><span class=\"pl-s1\"><span class=\"pl-c\"><span class=\"pl-c\">//</span> comment</span></span></span>\n<span class=\"pl-s\"><span class=\"pl-s1\"><span class=\"pl-pse\">}</span></span><span class=\"pl-pds\">`</span></span>;</pre></div>\n<h3>Parenthesize await correctly (<a href=\"https://urls.greenkeeper.io/prettier/prettier/pull/1513\" class=\"issue-link js-issue-link\" data-url=\"https://github.com/prettier/prettier/issues/1513\" data-id=\"226504052\" data-error-text=\"Failed to load issue title\" data-permission-text=\"Issue title is private\">#1513</a>, <a href=\"https://urls.greenkeeper.io/prettier/prettier/pull/1595\" class=\"issue-link js-issue-link\" data-url=\"https://github.com/prettier/prettier/issues/1595\" data-id=\"228166278\" data-error-text=\"Failed to load issue title\" data-permission-text=\"Issue title is private\">#1595</a>, <a href=\"https://urls.greenkeeper.io/prettier/prettier/pull/1593\" class=\"issue-link js-issue-link\" data-url=\"https://github.com/prettier/prettier/issues/1593\" data-id=\"228134606\" data-error-text=\"Failed to load issue title\" data-permission-text=\"Issue title is private\">#1593</a>) by <a href=\"https://urls.greenkeeper.io/bakkot\" class=\"user-mention\">@bakkot</a> and <a href=\"https://urls.greenkeeper.io/existentialism\" class=\"user-mention\">@existentialism</a></h3>\n<p>We don't have an automated way to put parenthesis, we instead specify all the possible combinations of nodes and when they should or shouldn't have parenthesis. So there's likely a long tail of unusual combinations that are still remaining. In this case, we made <code>await</code> handling a lot more robust by both adding parenthesis where they are needed and removing them when they are not.</p>\n<div class=\"highlight highlight-source-js\"><pre><span class=\"pl-c\"><span class=\"pl-c\">//</span> Before</span>\n(<span class=\"pl-k\">await</span> spellcheck) <span class=\"pl-k\">&amp;&amp;</span> <span class=\"pl-smi\">spellcheck</span>.<span class=\"pl-en\">setChecking</span>(<span class=\"pl-c1\">false</span>);\n<span class=\"pl-k\">new</span> <span class=\"pl-en\">A</span>((<span class=\"pl-k\">await</span> x));\n\n<span class=\"pl-c\"><span class=\"pl-c\">//</span> After</span>\n<span class=\"pl-k\">await</span> (spellcheck <span class=\"pl-k\">&amp;&amp;</span> <span class=\"pl-smi\">spellcheck</span>.<span class=\"pl-en\">setChecking</span>(<span class=\"pl-c1\">false</span>));\n<span class=\"pl-k\">new</span> <span class=\"pl-en\">A</span>(<span class=\"pl-k\">await</span> x);</pre></div>\n<h3>Preserve getter/setter info on flow ObjectTypeProperty (<a href=\"https://urls.greenkeeper.io/prettier/prettier/pull/1585\" class=\"issue-link js-issue-link\" data-url=\"https://github.com/prettier/prettier/issues/1585\" data-id=\"228009027\" data-error-text=\"Failed to load issue title\" data-permission-text=\"Issue title is private\">#1585</a>) by <a href=\"https://urls.greenkeeper.io/josephfrazier\" class=\"user-mention\">@josephfrazier</a></h3>\n<p>Another long tail option that we haven't got right!</p>\n<div class=\"highlight highlight-source-js\"><pre><span class=\"pl-c\"><span class=\"pl-c\">//</span> Before</span>\ntype <span class=\"pl-c1\">T</span> <span class=\"pl-k\">=</span> { <span class=\"pl-en\">method</span><span class=\"pl-k\">:</span> () <span class=\"pl-k\">=&gt;</span> <span class=\"pl-k\">void</span> };\n\n<span class=\"pl-c\"><span class=\"pl-c\">//</span> After</span>\ntype <span class=\"pl-c1\">T</span> <span class=\"pl-k\">=</span> { get <span class=\"pl-en\">method</span>()<span class=\"pl-k\">:</span> <span class=\"pl-k\">void</span> }</pre></div>\n<h3>Add parenthesis for single arg types with generics (<a href=\"https://urls.greenkeeper.io/prettier/prettier/pull/1814\" class=\"issue-link js-issue-link\" data-url=\"https://github.com/prettier/prettier/issues/1814\" data-id=\"232114140\" data-error-text=\"Failed to load issue title\" data-permission-text=\"Issue title is private\">#1814</a>)</h3>\n<p>Another case of sneaky parenthesis that we didn't properly add!</p>\n<div class=\"highlight highlight-source-js\"><pre><span class=\"pl-c\"><span class=\"pl-c\">//</span> Before</span>\ntype ExtractType <span class=\"pl-k\">=</span> <span class=\"pl-k\">&lt;</span><span class=\"pl-c1\">A</span><span class=\"pl-k\">&gt;</span><span class=\"pl-c1\">B</span><span class=\"pl-k\">&lt;</span><span class=\"pl-c1\">C</span><span class=\"pl-k\">&gt;</span> <span class=\"pl-k\">=&gt;</span> <span class=\"pl-c1\">D</span>\n\n<span class=\"pl-c\"><span class=\"pl-c\">//</span> After</span>\ntype ExtractType <span class=\"pl-k\">=</span> <span class=\"pl-k\">&lt;</span><span class=\"pl-c1\">A</span><span class=\"pl-k\">&gt;</span>(<span class=\"pl-c1\">B</span><span class=\"pl-k\">&lt;</span><span class=\"pl-c1\">C</span><span class=\"pl-k\">&gt;</span>) <span class=\"pl-k\">=&gt;</span> <span class=\"pl-c1\">D</span></pre></div>\n<h3>Fall back to non-strict mode in babylon (<a href=\"https://urls.greenkeeper.io/prettier/prettier/pull/1587\" class=\"issue-link js-issue-link\" data-url=\"https://github.com/prettier/prettier/issues/1587\" data-id=\"228060480\" data-error-text=\"Failed to load issue title\" data-permission-text=\"Issue title is private\">#1587</a>, <a href=\"https://urls.greenkeeper.io/prettier/prettier/pull/1608\" class=\"issue-link js-issue-link\" data-url=\"https://github.com/prettier/prettier/issues/1608\" data-id=\"228571463\" data-error-text=\"Failed to load issue title\" data-permission-text=\"Issue title is private\">#1608</a>) by <a href=\"https://urls.greenkeeper.io/josephfrazier\" class=\"user-mention\">@josephfrazier</a></h3>\n<p>We want prettier to be able to parse all the JavaScript out there. For babylon parser, we have to chose whether a file is using strict mode or not. We opted in to use strict mode by default as most files parse that way. But if you have octal literals like <code>0775</code>, it would not even parse. Now if it fails to parse in strict mode, we're going to try again in non-strict. We also allow <code>return</code> outside of a function as it's valid in node files.</p>\n<div class=\"highlight highlight-source-js\"><pre><span class=\"pl-c\"><span class=\"pl-c\">//</span> Before</span>\n<span class=\"pl-c1\">SyntaxError</span>\n\n<span class=\"pl-c\"><span class=\"pl-c\">//</span> After</span>\n<span class=\"pl-k\">return</span> <span class=\"pl-c1\">0775</span>;</pre></div>\n<h1>CLI</h1>\n<h3>Allow <code>--write</code> to be used with <code>--list-different</code> (<a href=\"https://urls.greenkeeper.io/prettier/prettier/pull/1633\" class=\"issue-link js-issue-link\" data-url=\"https://github.com/prettier/prettier/issues/1633\" data-id=\"230094197\" data-error-text=\"Failed to load issue title\" data-permission-text=\"Issue title is private\">#1633</a>)</h3>\n<p>This is useful to combine the two if you are writing a commit hook to tell the user what actually changed in a single command.</p>\n<h3>Ignore node_modules when running prettier from CLI (<a href=\"https://urls.greenkeeper.io/prettier/prettier/pull/1683\" class=\"issue-link js-issue-link\" data-url=\"https://github.com/prettier/prettier/issues/1683\" data-id=\"230825871\" data-error-text=\"Failed to load issue title\" data-permission-text=\"Issue title is private\">#1683</a>) by <a href=\"https://urls.greenkeeper.io/thymikee\" class=\"user-mention\">@thymikee</a></h3>\n<p>It's very easy to run prettier over the <code>node_modules/</code> folder by mistake which is something you almost never want to. So now we disable it by default and add a <code>--with-node-modules</code> option if you really want to.</p>\n<h3>Traverse dot files for glob (<a href=\"https://urls.greenkeeper.io/prettier/prettier/pull/1844\" class=\"issue-link js-issue-link\" data-url=\"https://github.com/prettier/prettier/issues/1844\" data-id=\"232967093\" data-error-text=\"Failed to load issue title\" data-permission-text=\"Issue title is private\">#1844</a>) by <a href=\"https://urls.greenkeeper.io/jhgg\" class=\"user-mention\">@jhgg</a></h3>\n<p>We enabled the option to go through .dotfiles in the glob parsing library we are using. This means that writing <code>*</code> will now catch <code>.eslintrc</code>.</p>\n</details>\n\n\n<details>\n  <summary>Not sure how things should work exactly?</summary>\n\n  There is a collection of [frequently asked questions](https://greenkeeper.io/faq.html) and of course you may always [ask my humans](https://github.com/greenkeeperio/greenkeeper/issues/new).\n</details>\n\n\n---\n\n\nYour [Greenkeeper](https://greenkeeper.io) Bot :palm_tree:\n\n"},"comment":{"url":"https://api.github.com/repos/patrykomiotek/seo-monitor-front/issues/comments/395850227","html_url":"https://github.com/patrykomiotek/seo-monitor-front/pull/92#issuecomment-395850227","issue_url":"https://api.github.com/repos/patrykomiotek/seo-monitor-front/issues/92","id":395850227,"node_id":"MDEyOklzc3VlQ29tbWVudDM5NTg1MDIyNw==","user":{"login":"greenkeeper[bot]","id":23040076,"node_id":"MDM6Qm90MjMwNDAwNzY=","avatar_url":"https://avatars3.githubusercontent.com/in/505?v=4","gravatar_id":"","url":"https://api.github.com/users/greenkeeper%5Bbot%5D","html_url":"https://github.com/apps/greenkeeper","followers_url":"https://api.github.com/users/greenkeeper%5Bbot%5D/followers","following_url":"https://api.github.com/users/greenkeeper%5Bbot%5D/following{/other_user}","gists_url":"https://api.github.com/users/greenkeeper%5Bbot%5D/gists{/gist_id}","starred_url":"https://api.github.com/users/greenkeeper%5Bbot%5D/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/greenkeeper%5Bbot%5D/subscriptions","organizations_url":"https://api.github.com/users/greenkeeper%5Bbot%5D/orgs","repos_url":"https://api.github.com/users/greenkeeper%5Bbot%5D/repos","events_url":"https://api.github.com/users/greenkeeper%5Bbot%5D/events{/privacy}","received_events_url":"https://api.github.com/users/greenkeeper%5Bbot%5D/received_events","type":"Bot","site_admin":false},"created_at":"2018-06-08T18:34:43Z","updated_at":"2018-06-08T18:34:43Z","author_association":"NONE","body":"## Version **1.13.5** just got published. \n[Update to this version instead 🚀](https://github.com/patrykomiotek/seo-monitor-front/compare/dev...patrykomiotek:greenkeeper%2Fprettier-1.13.5) \n"}}
{"actor":{"display_login":"greenkeeper"}}