• ❌ continuous-integration/travis-ci/push: The Travis CI build could not complete due to an error (Details).

3.9.1 (2019-05-23)

Bug Fixes

• requireReadOnlyReactProps (#406) (712d840)

The new version differs by 1 commits.

• 712d840 fix: requireReadOnlyReactProps (#406)

See the full diff

There is a collection of frequently asked questions. If those don’t help, you can always ask the humans behind Greenkeeper.

• ❌ continuous-integration/travis-ci/push The Travis CI build could not complete due to an error Details

15.5.0 (April 7, 2017)

React

• Added a deprecation warning for React.createClass. Points users to create-react-class instead. (@acdlite in d9a4fa4)
• Added a deprecation warning for React.PropTypes. Points users to prop-types instead. (@acdlite in 043845c)
• Fixed an issue when using ReactDOM together with ReactDOMServer. (@wacii in #9005)
• Fixed issue with Closure Compiler. (@anmonteiro in #8895)
• Another fix for Closure Compiler. (@Shastel in #8882)
• Added component stack info to invalid element type warning. (@n3tr in #8495)

React DOM

• Fixed Chrome bug when backspacing in number inputs. (@nhunzaker in #7359)
• Added react-dom/test-utils, which exports the React Test Utils. (@bvaughn)

React Test Renderer

• Fixed bug where componentWillUnmount was not called for children. (@gre in #8512)
• Added react-test-renderer/shallow, which exports the shallow renderer. (@bvaughn)

React Addons

• Last release for addons; they will no longer be actively maintained.
• Removed peerDependencies so that addons continue to work indefinitely. (@acdlite and @bvaughn in 8a06cd7 and 67a8db3)
• Updated to remove references to React.createClass and React.PropTypes (@acdlite in 12a96b9)
• react-addons-test-utils is deprecated. Use react-dom/test-utils and react-test-renderer/shallow instead. (@bvaughn)

There is a collection of frequently asked questions and of course you may always ask my humans.

• ❌ continuous-integration/travis-ci/push The Travis CI build could not complete due to an error Details

There is a collection of frequently asked questions and of course you may always ask my humans.

• ❌ continuous-integration/travis-ci/push The Travis CI build could not complete due to an error Details

The new version differs by 33 commits .

• 8ab9528 v2.8.1
• 75d1390 Merge pull request #876 from kentcdodds/pr/support-15.5
• 21f6e7a [Tests] create-react-class should be a static dev dependency.
• 4464a17 [Tests] move helpers in to test/_helpers dir
• 22f368f address final comments
• cc78489 Update error message in react-compat
• b48e551 Change condition in performBatchedUpdates to a version check
• 2f957af REACT155 constant is now true for react 15.5 or above
• f5f6001 Update ReactWrapperComponent to use prop-types package
• 3ff9832 Update karma cofig to be compatible with [email protected]
• ec7bbc5 Lint
• 270ee7f Remove unnecessary tests
• d6badda Fix import
• edeb99c Remove dependency on create-react-class
• b0e2fac Extract batchedUpdates to a function

There are 33 commits in total. See the full diff.

There is a collection of frequently asked questions and of course you may always ask my humans.

• ❌ continuous-integration/travis-ci/push: The Travis CI build failed (Details).

New features

You can now set a timeout for test themselves. The test will fail if this timeout is exceeded. The timeout is reset each time an assertion is made:

test('foo', t => {
	t.timeout(100); // 100 milliseconds
	// Write your assertions here
});

b65c6d7

AVA also has a global timeout feature. The mini reporter now logs tests that were pending when those timeouts occur. Additionally, if you interrupt a test using ctrl+c we'll now also show the pending tests. 2b60556

Thank you @dflupu for your hard work on this!

Bug fixes and other improvements

• We're no longer truncating multi-line error messages 72e0762
• Unexpected errors in the throws assertions are now reported with the correct stack trace ad087f2
• The Debugging with VSCode recipe has been updated with the correct workspaceFolder variable 0a5fe42 and --serial argument placement edfc005

All changes 📚

v1.1.0...v1.2.0

Thanks 💌

💖 Huge thanks to @anishkny, @CrispusDH, @dflupu and @niktekusho for helping us with this release. We couldn’t have done it without you!

Get involved ✌️

We welcome new contributors. AVA is a friendly place to get started in open source. We have a great article on getting started contributing and a comprehensive contributing guide.

The new version differs by 11 commits.

• 010914b 1.2.0
• ad087f2 Fix stack traces in throw assertions
• 8ad5efd Bump dependencies
• 2b60556 Print pending tests on interrupt, and on timeout in mini reporter
• 0a5fe42 Change deprecated workspaceRoot variable to the equivalent workspaceFolder
• b65c6d7 Add t.timeout()
• ed7807e Linter fixes
• f0a07cd Rely on npm 6.6.0
• 6b10f2e Bump XO and fix some lint issues
• 72e0762 Fix accidental truncation of multi-line error messages
• edfc005 Fix profile.js example

See the full diff

There is a collection of frequently asked questions. If those don’t help, you can always ask the humans behind Greenkeeper.

• ❌ continuous-integration/travis-ci/push The Travis CI build could not complete due to an error Details

• Improved incremental rebuilds for better performance in watch mode.
• Switched to read-cache for file reading for better performance.
• Set a dummy filename when reading from stdin to help plugins like autoprefixer find config files.
• Updated fs-promise dependency.

The new version differs by 7 commits .

• 0681c8d 3.1.0
• ea94fef Update CHANGELOG
• b7840e6 Update Badges
• b44a1b7 Update fs-promise
• 3daccc1 Set from option for stdin to process.cwd() + 'stdin' (#115)
• 097f37a Improve incremental rebuild; use absolute paths internally (#113)
• ffc3b30 Use read-cache to cache file reads for performance

See the full diff.

There is a collection of frequently asked questions and of course you may always ask my humans.

• ❌ continuous-integration/travis-ci/push The Travis CI build could not complete due to an error Details

There is a collection of frequently asked questions and of course you may always ask my humans.

• ❌ continuous-integration/travis-ci/push The Travis CI build could not complete due to an error Details

<a name"2.32.1">

2.32.1 (2017-04-19)

Bug Fixes

• rename no-types-missing-flow-annotation to no-types-missing-file-annotation (bb444dbf)

The new version differs by 1 commits .

• bb444db fix: rename no-types-missing-flow-annotation to no-types-missing-file-annotation

See the full diff.

There is a collection of frequently asked questions and of course you may always ask my humans.

• ❌ continuous-integration/travis-ci/push The Travis CI build could not complete due to an error Details

<a name"5.0.1">

5.0.1 (2017-06-08)

Bug Fixes

• Change splitter regex to use .* instead of .+ (#117) (b10de512, closes #114, #116)

The new version differs by 2 commits.

• b10de51 fix: Change splitter regex to use .* instead of .+ (#117)
• c9908f3 test(JSON): add JSON value tests that work on both Windows and UNIX (#112)

See the full diff

There is a collection of frequently asked questions and of course you may always ask my humans.

• ❌ continuous-integration/travis-ci/push: The Travis CI build failed (Details).

The new version differs by 29 commits.

• 2941c50 Bump to v3.2.19.
• 0c9700a Update deps.
• 40651a8 Make builtin-errors expose more stack.
• 90fa0c1 Cleanup matches().
• a7859b4 Remove -m alias detection from FLAGS.type.
• 5b5eba9 Add FLAGS.experimentalJSONModules.
• 1ea356b Rename Runtime._runResult to Runtime.runResult.
• 427cc17 Cleanup cjsVars compile options assignment in Runtime.compileEval() and Runtime.compileGlobalEval().
• 40bf1e0 Don't clip stack traces of parse/syntax errors.
• bc3b212 Newline nits.
• 4e6d73e Don't use URLs in stack traces if options.cjs.paths is true.
• d8dcf0d Update mocha link to require options (#758)
• 1d93fb3 Add util.format() and util.formatWithOptions() tests.
• e411656 Add copyright header to src/util/format.
• 371e752 Add type guard to safeFormatWithOptions.

There are 29 commits in total.

See the full diff

There is a collection of frequently asked questions. If those don’t help, you can always ask the humans behind Greenkeeper.

• ❌ continuous-integration/travis-ci/push The Travis CI build could not complete due to an error Details

• ✅ coverage/coveralls First build on greenkeeper/eslint-plugin-flowtype-2.30.1 at 83.824% Details

• ✅ codecov/project 83.82% remains the same compared to c3af213 Details

• ✅ codecov/patch Coverage not affected when comparing c3af213...8fad20d Details

The new version differs by 10 commits (ahead by 10, behind by 2).

• c2f959e 2.30.1
• 2243076 fix: force release
• 5de0277 chore: use babel-preset-env
• 51ae588 refactor: use standard export syntax
• e939596 fix: use semantic-release
• 0f23196 chore: remove commitmsg linting
• 751ac95 chore: release 2.30.0
• def54e1 docs: update documentation
• 1242ab4 fix: ensure colon is not null in typeColonSpacing reporter (#197)
• 42ba3e4 docs: fix typo (#195)

See the full diff.

There is a collection of frequently asked questions and of course you may always ask my humans.

• ❌ continuous-integration/travis-ci/push The Travis CI build could not complete due to an error Details

There is a collection of frequently asked questions and of course you may always ask my humans.

• ❌ continuous-integration/travis-ci/push: The Travis CI build could not complete due to an error (Details).

There is a collection of frequently asked questions. If those don’t help, you can always ask the humans behind Greenkeeper.

• ❌ continuous-integration/travis-ci/push The Travis CI build could not complete due to an error Details

There is a collection of frequently asked questions and of course you may always ask my humans.

• ❌ continuous-integration/travis-ci/push: The Travis CI build failed (Details).

The new version differs by 61 commits.

• 0499050 bump to v2.17.0
• f479635 [webpack] v0.11.1
• 8a4226d Merge pull request #1320 from bradzacher/export-ts-namespaces
• 988e12b fix(export): Support typescript namespaces
• 70c3679 [docs] make rule names consistent
• 6ab25ea [Tests] skip a TS test in eslint < 4
• 405900e [Tests] fix tests from #1319
• 2098797 [fix] export: false positives for typescript type + value export
• 70a59fe [fix] Fix overwriting of dynamic import() CallExpression
• e4850df [ExportMap] fix condition for checking if block comment
• 918567d [fix] namespace: add check for null ExportMap
• 2d21c4c Merge pull request #1297 from echenley/ech/fix-isBuiltIn-local-aliases
• 0ff1c83 [dev deps] lock typescript to ~, since it doesn’t follow semver
• 40bf40a [*] [deps] update resolve
• 28dd614 Merge pull request #1304 from bradennapier/feature/typescript-export-type

There are 61 commits in total.

See the full diff

There is a collection of frequently asked questions. If those don’t help, you can always ask the humans behind Greenkeeper.

There is a collection of frequently asked questions and of course you may always ask my humans.

• ❌ continuous-integration/travis-ci/push: The Travis CI build could not complete due to an error (Details).

The new version differs by 2 commits.

• 4bd049e 10.1.0
• 2c754a8 Update Babel to ^7.7.0 and enable Flow enums parsing (#812)

See the full diff

There is a collection of frequently asked questions. If those don’t help, you can always ask the humans behind Greenkeeper.

• ❌ continuous-integration/travis-ci/push: The Travis CI build failed (Details).

🔗 Release Notes

There is a collection of frequently asked questions. If those don’t help, you can always ask the humans behind Greenkeeper.

• ❌ continuous-integration/travis-ci/push The Travis CI build could not complete due to an error Details

Swapped Array.includes for array-includes polyfill to support node versions <4

The new version differs by 3 commits0.

• bf0ac6a 5.0.1
• fb8c626 Upgrade all dependencies.
• fb5b87a Fix: backward compatibility with node.js v4 and v5. (#231)

false

See the full diff

There is a collection of frequently asked questions and of course you may always ask my humans.

• ❌ continuous-integration/travis-ci/push The Travis CI build could not complete due to an error Details

There is a collection of frequently asked questions and of course you may always ask my humans.

• ❌ continuous-integration/travis-ci/push: The Travis CI build could not complete due to an error (Details).

Fixed

• Fix prop-types crash on multiple destructuring (#2319 @golopot)

The new version differs by 3 commits.

• 62255af Update CHANGELOG and bump version
• 655eb01 Merge pull request #2320 from golopot/issue-2319
• 9639d82 [Fix] prop-types: fix crash on multiple destructuring

See the full diff

There is a collection of frequently asked questions. If those don’t help, you can always ask the humans behind Greenkeeper.

Greenkeeper has checked the engines key in any package.json file, the .nvmrc file, and the .travis.yml file, if present.

• engines was only updated if it defined a single version, not a range.
• .nvmrc was updated to Node.js 10
• .travis.yml was only changed if there was a root-level node_js that didn’t already include Node.js 10, such as node or lts/*. In this case, the new version was appended to the list. We didn’t touch job or matrix configurations because these tend to be quite specific and complex, and it’s difficult to infer what the intentions were.

For many simpler .travis.yml configurations, this PR should suffice as-is, but depending on what you’re doing it may require additional work or may not be applicable at all. We’re also aware that you may have good reasons to not update to Node.js 10, which is why this was sent as an issue and not a pull request. Feel free to delete it without comment, I’m a humble robot and won’t feel rejected 🤖

There is a collection of frequently asked questions. If those don’t help, you can always ask the humans behind Greenkeeper.

• ❌ continuous-integration/travis-ci/push The Travis CI build could not complete due to an error Details

15.5.0 (April 7, 2017)

React

• Added a deprecation warning for React.createClass. Points users to create-react-class instead. (@acdlite in d9a4fa4)
• Added a deprecation warning for React.PropTypes. Points users to prop-types instead. (@acdlite in 043845c)
• Fixed an issue when using ReactDOM together with ReactDOMServer. (@wacii in #9005)
• Fixed issue with Closure Compiler. (@anmonteiro in #8895)
• Another fix for Closure Compiler. (@Shastel in #8882)
• Added component stack info to invalid element type warning. (@n3tr in #8495)

React DOM

• Fixed Chrome bug when backspacing in number inputs. (@nhunzaker in #7359)
• Added react-dom/test-utils, which exports the React Test Utils. (@bvaughn)

React Test Renderer

• Fixed bug where componentWillUnmount was not called for children. (@gre in #8512)
• Added react-test-renderer/shallow, which exports the shallow renderer. (@bvaughn)

React Addons

• Last release for addons; they will no longer be actively maintained.
• Removed peerDependencies so that addons continue to work indefinitely. (@acdlite and @bvaughn in 8a06cd7 and 67a8db3)
• Updated to remove references to React.createClass and React.PropTypes (@acdlite in 12a96b9)
• react-addons-test-utils is deprecated. Use react-dom/test-utils and react-test-renderer/shallow instead. (@bvaughn)

There is a collection of frequently asked questions and of course you may always ask my humans.

• ❌ continuous-integration/travis-ci/push: The Travis CI build failed (Details).

🔗 Changelog

There is a collection of frequently asked questions. If those don’t help, you can always ask the humans behind Greenkeeper.

• ❌ continuous-integration/travis-ci/push: The Travis CI build failed (Details).

There is a collection of frequently asked questions. If those don’t help, you can always ask the humans behind Greenkeeper.

• ❌ continuous-integration/travis-ci/push The Travis CI build could not complete due to an error Details

15.5.0 (April 7, 2017)

React

• Added a deprecation warning for React.createClass. Points users to create-react-class instead. (@acdlite in d9a4fa4)
• Added a deprecation warning for React.PropTypes. Points users to prop-types instead. (@acdlite in 043845c)
• Fixed an issue when using ReactDOM together with ReactDOMServer. (@wacii in #9005)
• Fixed issue with Closure Compiler. (@anmonteiro in #8895)
• Another fix for Closure Compiler. (@Shastel in #8882)
• Added component stack info to invalid element type warning. (@n3tr in #8495)

React DOM

• Fixed Chrome bug when backspacing in number inputs. (@nhunzaker in #7359)
• Added react-dom/test-utils, which exports the React Test Utils. (@bvaughn)

React Test Renderer

• Fixed bug where componentWillUnmount was not called for children. (@gre in #8512)
• Added react-test-renderer/shallow, which exports the shallow renderer. (@bvaughn)

React Addons

• Last release for addons; they will no longer be actively maintained.
• Removed peerDependencies so that addons continue to work indefinitely. (@acdlite and @bvaughn in 8a06cd7 and 67a8db3)
• Updated to remove references to React.createClass and React.PropTypes (@acdlite in 12a96b9)
• react-addons-test-utils is deprecated. Use react-dom/test-utils and react-test-renderer/shallow instead. (@bvaughn)

There is a collection of frequently asked questions and of course you may always ask my humans.

Facebook Adoption Update

The reason why I (@vjeux) embarked on this journey working on prettier has always been to get the entire Facebook codebase converted over. I would like to give an update on how it is going and what is the process to get there.

The first projects to adopt prettier were Jest, React and immutable-js. Those are small codebases in the order of hundreds of files that have their own infrastructure. There are 5 or less people working on them full time.

Then, Oculus and Nuclide converted their codebase over. The scale is bigger with a few thousands of files and tens of full time contributors but looks pretty similar to the first projects. The conversions went in one big codemod and that's it.

Now, the entire Facebook codebase is way bigger than this and it's not feasible to just convert everything in one go and to convince everyone that their entire codebase is going to be reformatted under their feet. So we need to find a more incremental approach.

Scaling adoption

Running prettier on a piece of code is a pretty expensive operation, it makes your pull request look bad because of a lot of unrelated changes and it causes merge conflicts for all the outstanding pull requests. So once a file has been formatted, you should do everything to make sure it remains formatted.

• When pretty-printing a file, add @format to the first block comment like @flow.
• Have a lint rule with autofix that checks if the file is correctly pretty printed when @format is present.
  • When running Nuclide, it's going to show as an inline warning and have a fix button.
  • When sending a pull request, it's going to show the lint failing with a [Yn] prompt that you can just press enter.
• Update the default code templates to add @format to the header.
• When you run code formatting via cmd-shift-c inside of Nuclide, automatically insert the @format header.
• Disable all the stylistic rules like max-len when @format is in the header.
• Have script to run prettier through an entire folder with everything configured as a one line operation.
• Have a good guide to help people that want to convert their codebase over with instructions and best practices.
• When pushing a new release of prettier, also run it through all the files with @format in order to avoid getting warnings afterwards.
• Add tracking for the number of files with @format over time.

We finally got all those things wired up 1.5 weeks ago and the reception has been insane. Many people from various teams converted their codebase to prettier on their own. As of today, 15% of Facebook codebase has been converted over!

When I started working on prettier, I had a hunch that people were hungry for tools to solve formatting. But I had no idea that once the tooling was in place, people would rush to convert their codebase over! This is great confirmation that this project is useful to people and not just a gimmicky tool.

TypeScript Support Progress

@despairblue, @azz and @JamesHenry have been hard at work around getting TypeScript supported by prettier as it's the top requested feature. 2000 out of 11000 files in the TypeScript test suite are not yet properly printed. You can follow progress on #1480 and do not hesitate to help out!

Flow

Add trailing commas on flow generics (#1381)

The --trailing-comma=all option is supposed to add trailing commas everywhere possible, but as an oversight we forgot to do it for flow generics.

// Before
type Errors = Immutable.Map<
  Ahohohhohohohohohohohohohohooh,
  Fbt | Immutable.Map<ErrorIndex, Fbt>
>;
// After

type Errors = Immutable.Map<

Ahohohhohohohohohohohohohohooh,

Fbt | Immutable.Map<ErrorIndex, Fbt>,

>;

Inline nullable in flow generics (#1426)

The phase after printing things correctly is to tweak the output to make it closer to the way people write code in practice. Inlining optional flow types is a small thing that makes a difference.

// Before
type Cursor = Promise<
  ?{
    newCursor?: number,
    formatted: string,
  }
>;
// After

type Cursor = Promise<?{

newCursor?: number,

formatted: string,

}>;

Allow flow declarations to break on StringLiteralTypeAnnotations (#1437)

We can always find more places to add breaks when things don't fit 80 columns. This time it's around declaring a type as a constant string.

// Before
export type AdamPlacementValidationSingleErrorKey = 'SOME_FANCY_TARGETS.GLOBAL_TARGET';
// After

export type AdamPlacementValidationSingleErrorKey =

'SOME_FANCY_TARGETS.GLOBAL_TARGET';

Add space around = for flow generics default arguments (#1476)

Another example of small thing where we can improve the display of flow code. For function default arguments we put a space around = but didn't around flow generics.

// Before
class PolyDefault<T=string> {}
// After

class PolyDefault<T = string> {}

Don't break for unparenthesised single argument flow function (#1452)

I'm trying to figure out something to write here, but ... it just looks weird!

// Before
const selectorByPath:
  Path
 => SomethingSelector<
  SomethingUEditorContextType,
  SomethingUEditorContextType,
  SomethingBulkValue<string>
> = memoizeWithArgs(/* ... */)
// After

const selectorByPath: Path => SomethingSelector<

SomethingUEditorContextType,

SomethingUEditorContextType,

SomethingBulkValue<string>

> = memoizeWithArgs(/* ... */);

Fix optional flow parenthesis (#1357)

We were a bit too lenient around parenthesis for optional flow types. In one case in the entire Facebook codebase, it generated code with different semantics. As part of this fix, we hardened the list of types that can be written without parenthesis.

// Before
type X = ?(number, number) => number => void;
// After

type X = (?(number, number) => number) => void;

Skip trailing commas with FlowShorthandWithOneArg (#1364)

It is a parse error to add a trailing comma without parenthesis for arguments of arrow function types. We found one case in Facebook codebase when this happened, it's a very rare occurrence.

// Before
type IdeConnectionFactory =
  child_process$ChildProcess,
  => FlowIDEConnection = defaultIDEConnectionFactory;
// After

type IdeConnectionFactory =

child_process$ChildProcess,

=> FlowIDEConnection = defaultIDEConnectionFactory;

Reorder flow object props (#1451)

This one is an example where the way the AST is structured is not our favor. Instead of having a list of elements inside of a type, the AST is structured in a way where normal keys and array keys each have their own group. In order to restore the initial order, we're now reading from the original source :(

// Before
type Foo = {
  [key: string]: void,
  alpha: "hello",
  beta: 10
};
// After

type Foo = {

alpha: 'hello',

[key: string]: void,

beta: 10

}

Template Literal

Proper indentation for template literals (#1385)

A long standing issue with template literals and prettier is around the indentation of code inside of ${}. It used to be the indentation of the backtick but turned out to give poor results. Instead people tend to use the indent of the ${. We changed this behavior and it magically made GraphQL queries look pretty!

// Before
Relay.createContainer({
  nodes: ({ solution_type, time_frame }) => Relay.QL`
    fragment {
      __typename
      ${OptimalSolutionsSection.getFragment("node", {
    solution_type,
    time_frame
  })}
    }
  `
})

// After
Relay.createContainer({
  nodes: ({ solution_type, time_frame }) => Relay.QL`
    fragment {
      __typename
      ${OptimalSolutionsSection.getFragment("node", {
        solution_type,
        time_frame
      })}
    }
  `
})

Do not indent calls with a single template literal argument (#873)

Template literals are very hard to deal with for a pretty printer because the spaces inside are meaningful so you can't re-indent them. We didn't know what to do for a call with a single template literal so we didn't do anything, but we kept receiving reports of people saying that prettier indented it the wrong way, so we are now inlining them. Fingers crossed it is going to cover most use cases.

// Before
insertRule(
  `*, *:before, *:after {
    box-sizing: inherit;
  }`
);
// After

insertRule(</span>*, *:before, *:after {</span> <span class="pl-s">  box-sizing: inherit;</span> <span class="pl-s">}<span class="pl-pds">);

Fix windows line ending on template literals (#1439)

We manipulate line endings in a lot of places in prettier and took great care of handling both \n and \r\n except for template literals where we forgot. Now this is fixed!

// Before
const aLongString = `

Line 1

Line 2

Line 3

`;
// After

const aLongString = </span></span> <span class="pl-s">Line 1</span> <span class="pl-s">Line 2</span> <span class="pl-s">Line 3</span> <span class="pl-s"><span class="pl-pds">;

Inline template literals as arrow body (#1485)

We already inline template literals that are tagged (eg graphql`query`) but didn't for plain template literals. For the anecdote, it turns out the code was supposed to support it but it was using TemplateElement instead of TemplateLiteral :(

// Before
const inlineStore = preloadedState =>
  `
  <script>
    window.preloadedState = ${JSON.stringify(preloadedState).replace(/</g, '\\u003c')}
  </script>
`
// After

const inlineStore = preloadedState => </span></span> <span class="pl-s">  &lt;script&gt;</span> <span class="pl-s">    window.preloadedState = <span class="pl-s1"><span class="pl-pse">${</span><span class="pl-c1">JSON</span>.<span class="pl-en">stringify</span>(preloadedState).<span class="pl-c1">replace</span>(<span class="pl-sr"><span class="pl-pds">/</span>&lt;<span class="pl-pds">/</span>g</span>, <span class="pl-s"><span class="pl-pds">'</span><span class="pl-cce">\\</span>u003c<span class="pl-pds">'</span></span>)<span class="pl-pse">}</span></span></span> <span class="pl-s">  &lt;/script&gt;</span> <span class="pl-s"><span class="pl-pds">

Ternaries

Add parenthesis for unusual nested ternaries (#1386)

While working on printing nested ternaries, everyone focused on the ones with the shape of an if then else cond1 ? elem1_if : cond2 ? elem2_if : elem_else which is the most common. But, if you move move some ? and : around you can have another pattern. It looks almost the same but has a different meaning. In order to reduce confusion, we're adding parenthesis around the uncommon form.

// Before
cond1 ? cond2 ? elem2_if : elem2_else : elem1_else
// After

cond1 ? (cond2 ? elem2_if : elem2_else) : elem1_else

Only add parenthesis on ternaries inside of arrow functions if doesn't break (#1450)

There's an eslint rule no-confusing-arrows which suggests adding parenthesis for ternaries in arrow functions without brackets.

var x = a => 1 ? 2 : 3;
var x = a <= 1 ? 2 : 3;

It makes sense when code is in one line, but when it is split into multiple lines, the parenthesis are unnecessary given the indentation, so we now only put them when they serve their disambiguation purpose.

// Before
var x = a => (1 ? 2 : 3);
var x = a =>
  (1
    ? 2
    : 3);
// After

var x = a => (1 ? 2 : 3);

var x = a =>

1

? 2

: 3;

General JavaScript Improvements

Inline function declaration with single arg as object (#1173)

This one was often requested for React Stateless Functional Components (SFC). If you make use of a lot of them, it's likely going to be a big change for you.

// Before
const X = (
  props: {
    a: boolean,
  },
) => <div />;
// After

const X = (props: {

a: boolean,

}) => <div />;

Break inline object first in function arguments (#1453)

One thing we discovered early on is that people usually break the arguments of the function before breaking the return type. Unfortunately, the code responsible to inline single destructuring argument broke that assumption and it introduced bad looking code like this example. The good news is that it enables us to turn on inlining for single arguments that are typed with an object.

// Before
class X {
  async onDidInsertSuggestion({editor, triggerPosition, suggestion}): Promise<
    void
  > {
  }
}
// After

class X {

async onDidInsertSuggestion({

editor,

triggerPosition,

suggestion

}): Promise<void> {

}

}

Don't break on empty arrays and objects (#1440)

This one has been a long standing issue and is an easy fix, but was an invaluable tool: whenever someone reported that [] or {} would break, we were able to fix the example by fixing something else. So it was a great way to surface edge cases. Fortunately, this vein has now ran out and all the recent examples just look bad with no other reason than the fact that they are breaking. So it's time to finally do it!

// Before
const a = someVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeLong.Expression || [
];
// After

const a = someVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeLong.Expression || [];

Do not break on [0] (#1441)

We have a lot of issues where code breaks in array access when it doesn't look good. We don't yet have a good generic solution for it, but we can add a specific fix a common situation: [0].

// Before
queryThenMutateDOM(() => {
  title = SomeThing.call(root, "someLongStringThatPushesThisTextReall")[
    0
  ];
});
// After

queryThenMutateDOM(() => {

title = SomeThing.call(

root,

"someLongStringThatPushesThisTextReall",

)[0];

});

Indent do while condition (#1373)

We were not using the correct indentation logic for do-while condition but someone noticed, now we do!

// Before
do {}
while (someVeryLongStringA && someVeryLongStringB && someVeryLongStringC && someVeryLongStringD);
// After

do {}

while (

someVeryLongStringA &&

someVeryLongStringB &&

someVeryLongStringC &&

someVeryLongStringD

);

Preserve inline comment as last argument (#1390)

We forgot to add one case in the comment detection code when they appear last for JSX attributes and function arguments which made them go after the closing. In the case of JSX, it generated code that had a different meaning. Fortunately, since we don't usually commit commented out code it didn't affect production code, but it is not a good experience while coding.

// Before
const x = (
  <div
    attr1={1}>
//   attr3={3}
    {children}
  </div>
);
// After

const x = (

<div

attr1={1}

//   attr3={3}

>

{children}

</div>

);

Break class expression returned by arrow call (#1464)

In 1.0, we made class be inline inside of arrow functions. It turns out that it doesn't work great when the class is non trivial, so we are reverting this change. We're trying really hard to avoid making trashy decisions like this where the style changes back and forth, but we allow ourselves to do it sometimes to fix mistakes!

// Before
export default (ViewComponent: Function, ContainerComponent: Function) => class
  extends React.Component {
  static propTypes = {};
};
// After

export default (ViewComponent: Function, ContainerComponent: Function) =>

class extends React.Component {

static propTypes = {};

};

Fix empty line in block with EmptyStatement (#1375)

This one was found by fuzzing. You're unlikely going to hit this in real code but it's good to know it is fixed!

// Input
if (a) {
  b;
;

}
// Before

if (a) {

b;
}
// After

if (a) {

b;
}

The new version differs by 48 commits0.

• a81d5c1 1.3.0
• 0785726 Inline template literals as arrow body (#1485)
• f59aeef Break inline object first in function arguments (#1453) (#1173)
• 8f9bb3a Break inline object first in function arguments (#1453)
• 54b8cac Reorder flow object props (#1451)
• c99a877 Do not break on [0] (#1441)
• acfb14f Don't break on empty arrays and objects (#1440)
• bafd724 Don't break for unparenthesised single argument flow function (#1452)
• a335c26 Add space around = for flow generics default arguments (#1476)
• 4b7d265 Fix windows line ending on template literals (#1439)
• e392093 Only add parenthesis on ternaries inside of arrow functions if doesn't break (#1450)
• 93cad97 Preserve inline comment as last argument (#1390)
• 314e963 Add parenthesis for unusual nested ternaries (#1386)
• 13f05fb Proper indentation for template literals (#1385)
• c521406 [RFC] Do not indent calls with a single template literal argument (#873)

There are 48 commits in total.

See the full diff

There is a collection of frequently asked questions and of course you may always ask my humans.

• ❌ continuous-integration/travis-ci/push The Travis CI build could not complete due to an error Details

The new version differs by 2 commits .

• d84fe2c v2.6.1
• e8cd685 only run rmdirSync 'retries' times when it throws

See the full diff.

There is a collection of frequently asked questions and of course you may always ask my humans.

• ❌ continuous-integration/travis-ci/push: The Travis CI build failed (Details).

The new version differs by 37 commits.

• b35a579 3.3.0
• cfe38fd Merge pull request #531 from lipis/dependabot/npm_and_yarn/lint-staged-8.1.4
• 97c319a Bump lint-staged from 8.1.3 to 8.1.4
• c8031a6 Merge pull request #529 from lipis/dependabot/npm_and_yarn/lint-staged-8.1.3
• 093ffe5 Bump lint-staged from 8.1.1 to 8.1.3
• f998756 Merge pull request #530 from lipis/dependabot/npm_and_yarn/prettier-1.16.4
• 6c8a726 Bump prettier from 1.16.3 to 1.16.4
• f321c14 Merge pull request #528 from lipis/dependabot/npm_and_yarn/prettier-1.16.3
• 03d0f24 Bump prettier from 1.16.2 to 1.16.3
• e612fcb Merge pull request #527 from lipis/dependabot/npm_and_yarn/prettier-1.16.2
• aa6f141 Bump prettier from 1.16.1 to 1.16.2
• 4b4a736 Merge pull request #526 from lipis/dependabot/npm_and_yarn/lint-staged-8.1.1
• a961a62 Bump lint-staged from 8.1.0 to 8.1.1
• 3735009 Merge pull request #525 from lipis/dependabot/npm_and_yarn/prettier-1.16.1
• 858e848 Bump prettier from 1.16.0 to 1.16.1

There are 37 commits in total.

See the full diff

There is a collection of frequently asked questions. If those don’t help, you can always ask the humans behind Greenkeeper.

• ❌ continuous-integration/travis-ci/push The Travis CI build could not complete due to an error Details

TypeScript Support

This is the most requested feature for prettier. With 1.4.0, you can now use prettier to format your .ts and .tsx files!

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 estree format for the JavaScript parts and then have special nodes for Flow-specific ones.

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.

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, @JamesHenry and @soda0289 wrote a project called typescript-eslint-parser which takes a TypeScript AST and convert it to an estree one, just what we need for prettier!

After that project got setup inside of prettier, @azz, @despairblue and @Pajn 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 :)

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!

CSS, Less and SCSS Support

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!

It turns out that CSS is a much smaller language than JavaScript and supporting it only took a few days. We are using postcss by @ai as the underlying parser which is able to parse CSS, Less and SCSS. We also depend on postcss-values-parser, postcss-selector-parser by @ben-eb postcss-media-query-parser by @dryoma.

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.

Note that prettier is currently just formatting the code, it does not respect any options yet such as singleQuote nor is doing any color or number normalization like we do for JavaScript.

Editor Integration

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.

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!

Add cursorOffset option for cursor translation (#1637) by @josephfrazier

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!

Add --range-start/end options to format only parts of the input (#1609) by @josephfrazier

This one is a very often requested feature. Right now prettier only formats the entire file. Now it is possible to format a range.

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!

Adding filepath option in order to enable filetype inference (#1835) by @mitermayer

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.

Highlights

Wrap text content inside of JSX (#1120, #1671, #1827, #1829) by @karl

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 {" "} 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.

This is an awesome piece of work by @karl 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.

// Before
<div>
  Please state your
  {" "}
  <b>name</b>
  {" "}
  and
  {" "}
  <b>occupation</b>
  {" "}
  for the board of directors.
</div>
// After

<div>

Please state your <b>name</b> and <b>occupation</b> for the board of

directors.

</div>

Remove parenthesis for JSX inside of arrow functions (#1733) by @xixixao

People writing functional components are going to be happy about this one. We no longer put parens for arrow functions that return JSX.

// Before
const render1 = ({ styles }) => (
  <div style={styles}>
      Keep the wrapping parens. Put each key on its own line.
  </div>
);
// After

const render1 = ({ styles }) =>

<div style={styles}>

Keep the wrapping parens. Put each key on its own line.

</div>;

Improve template literal printing (#1664, #1714) by @josephfrazier

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.

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 ${ starts, we indent where the line that contains ${ starts.

Let us know if you still have issues with how template literals output after this release!

// Before
const Bar = styled.div`
  color: ${props => (props.highlight.length > 0 ? palette([
                 'text',
                 'dark',
                 'tertiary'
               ])(props) : palette([
                 'text',
                 'dark',
                 'primary'
               ])(props))} !important;
`
// After

const Bar = styled.div</span></span> <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> <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> <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> <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> <span class="pl-s"><span class="pl-pds">

Use the same breaking rules for assignment and object values (#1721)

We have a lot of fine-tuned logic for how to break things after assignment (eg a = ...). 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.

// Before
const o = {
  somethingThatsAReallyLongPropName: this.props.cardType ===
    AwesomizerCardEnum.SEEFIRST,
};
// After

const o = {

somethingThatsAReallyLongPropName:

this.props.cardType === AwesomizerCardEnum.SEEFIRST,

};

Indent conditions inside of !() (#1731)

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!

// Before
const anyTestFailures = !(aggregatedResults.numFailedTests === 0 &&
  aggregatedResults.numRuntimeErrorTestSuites === 0);
// After

const anyTestFailures = !(

aggregatedResults.numFailedTests === 0 &&

aggregatedResults.numRuntimeErrorTestSuites === 0

);

Formatting Fixes

Put loop bodies on the same line when possible (#1498)

We were already doing this for if statements, we should be consistent and also do it for loops.

// Before
for (a in b)
  var c = {};
// After

for (a in b) var c = {};

Fix empty line with flow union (#1511) by @existentialism

We shouldn't indent things twice ;)

// Before
type Foo = Promise<
<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 }
<span class="pl-k">|</span> { ok<span class="pl-k">:</span> <span class="pl-c1">false</span>, bar<span class="pl-k">:</span> SomeOtherLongType }

>;
// After

type Foo = Promise<

{ ok: true, bar: string, baz: SomeOtherLongType } |

{ ok: false, bar: SomeOtherLongType }

>;

Do not put parens for single argument with end of line comment (#1518)
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 (/* comment */ num), not end of line comments.
// Before
KEYPAD_NUMBERS.map((num) => ( // Buttons 0-9
  <div />
));
KEYPAD_NUMBERS.map(num => ( // Buttons 0-9

<div />

));

Do not indent nested ternaries (#1822)
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.
// Before
aaaaaaaaaaaaaaa
  ? bbbbbbbbbbbbbbbbbb
  : ccccccccccccccc
      ? ddddddddddddddd
      : eeeeeeeeeeeeeee ? fffffffffffffff : gggggggggggggggg;
// After

aaaaaaaaaaaaaaa

? bbbbbbbbbbbbbbbbbb

: ccccccccccccccc

? ddddddddddddddd

: eeeeeeeeeeeeeee ? fffffffffffffff : gggggggggggggggg;

Inline chained conditionals inside of jsx attribute (#1519)
We don't need to use the indentation to disambiguate another block as nothing can come after.
// Before
<div
  src={
    !isEnabled &&
      diffUpdateMessageInput != null &&
      this.state.isUpdateMessageEmpty
  }
/>;
// After

<div

src={

!isEnabled &&

diffUpdateMessageInput != null &&

this.state.isUpdateMessageEmpty

}

/>;

Unescape unnecessarily escaped characters in strings (#1575) by @josephfrazier
We are already trying to cleanup strings in various ways, this is another small addition that's going to remove \ that are not needed.
// Before
a = 'hol\a';
// After

a = 'hola';

Fix boolean for empty objects (#1590) by @dmitrika
We want to inline objects inside of a boolean expression as it looks weird to have { 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.
const x = firstItemWithAVeryLongNameThatKeepsGoing ||
secondItemWithALongNameAsWell || {};
// After

const x =

firstItemWithAVeryLongNameThatKeepsGoing ||

secondItemWithALongNameAsWell ||

{};

Remove Parens from SequenceExpressions in ForStatements (#1597) by @k15a
It is common to assign multiple values inside of a for loop, now we don't add parenthesis anymore.
// Before
for ((i = 0), (len = arr.length); i < len; i++) {
// After

for (i = 0, len = arr.length; i < len; i++) {

Do not inline arrow when argument has a leading comment (#1660)
If you put block comments inside of arrow functions, we no longer mess everything up!
// Before
export const bem = block => /**
   * @param {String} [element] - the BEM Element within that block; if undefined, selects the block itself.
   */
element => /**
     * @param {?String} [modifier] - the BEM Modifier for the Block or Element; if undefined, selects the Block or Element unmodified.
     */
modifier =>
// After

export const bem = block =>

/

   * @param {String} [element] - the BEM Element within that block; if undefined, selects the block itself.

   */

element =>

/

     * @param {?String} [modifier] - the BEM Modifier for the Block or Element; if undefined, selects the Block or Element unmodified.

     */

modifier =>

Fix last comments of imports (#1677)
Another place where we have to do special logic for comments!
// Before
import {
  ExecutionResult,
  DocumentNode,
  /* tslint:disable */
  SelectionSetNode,
} /* tslint:enable */ from 'graphql';
// After

import {

DocumentNode,

/* tslint:disable /

SelectionSetNode,

/ tslint:enable */

} from 'graphql';

Handle comments in member chain (#1686, #1691)
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.
// Before
const configModel = this.baseConfigurationService.getCache().consolidated // global/default values (do NOT modify)
  .merge(this.cachedWorkspaceConfig);
// After

const configModel = this.baseConfigurationService

.getCache()

.consolidated // global/default values (do NOT modify)

.merge(this.cachedWorkspaceConfig);

Use expandLast for nested arrow functions (#1720)
// Before
f(action => next =>
    next(action));
// After

f(action => next =>

next(action),

);

Put JSX comments inside of the parenthesis (#1712)
This mostly affects Facebook engineers where we automatically add $FlowFixMe when pushing a new version of flow. Now it no longer messes up those comments.
// Before
const aDiv = /* $FlowFixMe */
(
  <div className="foo">
    Foo bar
  </div>
);
// After

const aDiv = (

/* $FlowFixMe */

<div className="foo">

Foo bar

</div>

);

Force \n for multiple variable declarations (#1723)
This one has been very often requested. We used to only break multiple variable declarations if the line was > 80 columns. Now we do it regardless if there's at least one with an assignment.
// Before
var numberValue1 = 1, numberValue2 = 2;
// After

var numberValue1 = 1,

numberValue2 = 2;

Inline | null and | void (#1734)
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 | null and | void.
// Before
interface RelayProps {
  articles:
    | Array<
      | {
        __id: string,
      }
      | null
    >
    | null
}
// After

interface RelayProps {

articles: Array<{

__id: string,

} | null> | null,

}

Break on implements instead of extends (#1730)
We no longer break on extends. This should make classes with extends that can break look less wonky.
// Before
class MyContractSelectionWidget
  extends React.Component<
    void,
    MyContractSelectionWidgetPropsType,
    void
  > {
  method() {}
}
// After

class MyContractSelectionWidget extends React.Component<

void,

MyContractSelectionWidgetPropsType,

void

> {

method() {}

}

Inline single import (#1729)
The same way we don't break long require calls, we no longer break import statements if there is only a single thing being imported.
// Before
import somethingSuperLongsomethingSuperLong
  from "somethingSuperLongsomethingSuperLongsomethingSuperLong";
// After

import somethingSuperLongsomethingSuperLong from "somethingSuperLongsomethingSuperLongsomethingSuperLong";

Add the ability for SequenceExpression to break (#1749)
Did you know that if none of your code were statements, you could use () instead of {} and , instead of ;? 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 ¯_(ツ)_/¯
// Before
const f = (argument1, argument2, argument3) =>
  (doSomethingWithArgument(argument1), doSomethingWithArgument(
    argument2
  ), argument1);
// After

const f = (argument1, argument2, argument3) => (

doSomethingWithArgument(argument1),

doSomethingWithArgument(argument2),

argument1

);

Don't force line break in empty loop bodies (#1815)
Loops with empty body no longer have their {} split into two lines.
// Before
while (true) {
}
// After

while (true) {}

Preserve empty lines between switch cases with comments (#1708)
// Before
switch (true) {
  case true:
  // Good luck getting here
  case false:
}
// After

switch (true) {

case true:
// Good luck getting here

case false:

}

Correctness
Remove ast-types (#1743, #1744, #1745, #1746, #1747)
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 type field, then it's a node.
// Before
Error: did not recognize object of type "ObjectTypeSpreadProperty"
// After

type X = {...Y//};

type X = {//...Y};

Preserve unusual unicode whitespace (#1658, #1165) by @karl and @yamafaktory
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!
Don't let trailing template literal comments escape (#1580, #1713, #1598, #1713) by @josephfrazier and @k15a
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 {} expressions. The idea is to introduce a boundary before the end of the } and if we still have unprinted comments, then flush them all at once, put a \n and print the }. We are now using this logic for template literals :)
// Before
`${0} // comment`;
// After

</span><span class="pl-s1"><span class="pl-pse">${</span></span></span> <span class="pl-s"><span class="pl-s1"><span class="pl-c1">0</span></span></span> <span class="pl-s"><span class="pl-s1"><span class="pl-c"><span class="pl-c">//</span> comment</span></span></span> <span class="pl-s"><span class="pl-s1"><span class="pl-pse">}</span></span><span class="pl-pds">;

Parenthesize await correctly (#1513, #1595, #1593) by @bakkot and @existentialism
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 await handling a lot more robust by both adding parenthesis where they are needed and removing them when they are not.
// Before
(await spellcheck) && spellcheck.setChecking(false);
new A((await x));
// After

await (spellcheck && spellcheck.setChecking(false));

new A(await x);

Preserve getter/setter info on flow ObjectTypeProperty (#1585) by @josephfrazier
Another long tail option that we haven't got right!
// Before
type T = { method: () => void };
// After

type T = { get method(): void }

Add parenthesis for single arg types with generics (#1814)
Another case of sneaky parenthesis that we didn't properly add!
// Before
type ExtractType = <A>B<C> => D
// After

type ExtractType = <A>(B<C>) => D

Fall back to non-strict mode in babylon (#1587, #1608) by @josephfrazier
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 0775, 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 return outside of a function as it's valid in node files.
// Before
SyntaxError
// After

return 0775;

CLI
Allow --write to be used with --list-different (#1633)
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.
Ignore node_modules when running prettier from CLI (#1683) by @thymikee
It's very easy to run prettier over the node_modules/ folder by mistake which is something you almost never want to. So now we disable it by default and add a --with-node-modules option if you really want to.
Traverse dot files for glob (#1844) by @jhgg
We enabled the option to go through .dotfiles in the glob parsing library we are using. This means that writing * will now catch .eslintrc.