Skip to content

Latest commit

Β 

History

History
4477 lines (3468 loc) Β· 128 KB

CHANGELOG.md

File metadata and controls

4477 lines (3468 loc) Β· 128 KB

3.3.3

diff

Add parentheses for nullish coalescing in ternary (#16391 by @cdignam-segment)

This change adds clarity to operator precedence.

// Input
foo ? bar ?? foo : baz;
foo ?? bar ? a : b;
a ? b : foo ?? bar;

// Prettier 3.3.2
foo ? bar ?? foo : baz;
foo ?? bar ? a : b;
a ? b : foo ?? bar;

// Prettier 3.3.3
foo ? (bar ?? foo) : baz;
(foo ?? bar) ? a : b;
a ? b : (foo ?? bar);

Add parentheses for decorator expressions (#16458 by @y-schneider)

Prevent parentheses around member expressions or tagged template literals from being removed to follow the stricter parsing rules of TypeScript 5.5.

// Input
@(foo`tagged template`)
class X {}

// Prettier 3.3.2
@foo`tagged template`
class X {}

// Prettier 3.3.3
@(foo`tagged template`)
class X {}

Support @let declaration syntax (#16474 by @sosukesuzuki)

Adds support for Angular v18 @let declaration syntax.

Please see the following code example. The @let declaration allows you to define local variables within the template:

@let name = 'Frodo';

<h1>Dashboard for {{name}}</h1>
Hello, {{name}}

For more details, please refer to the excellent blog post by the Angular Team: Introducing @let in Angular.

We also appreciate the Angular Team for kindly answering our questions to implement this feature.

3.3.2

diff

Fix handlebars path expressions starts with @ (#16358 by @Princeyadav05)

{{! Input }}
<div>{{@x.y.z}}</div>

{{! Prettier 3.3.1 }}
<div>{{@x}}</div>

{{! Prettier 3.3.2 }}
<div>{{@x.y.z}}</div>

3.3.1

diff

Preserve empty lines in front matter (#16347 by @fisker)

<!-- Input -->
---
foo:
  - bar1

  - bar2

  - bar3
---
Markdown

<!-- Prettier 3.3.0 -->

---
foo:
  - bar1
  - bar2
  - bar3
---

Markdown


<!-- Prettier 3.3.1 -->
---
foo:
  - bar1

  - bar2

  - bar3
---

Markdown

Preserve explicit language in front matter (#16348 by @fisker)

<!-- Input -->
---yaml
title: Hello
slug: home
---

<!-- Prettier 3.3.0 -->
---
title: Hello
slug: home
---

<!-- Prettier 3.3.1 -->
---yaml
title: Hello
slug: home
---

Avoid line breaks in import attributes (#16349 by @fisker)

// Input
import something from "./some-very-very-very-very-very-very-very-very-long-path.json" with { type: "json" };

// Prettier 3.3.0
import something from "./some-very-very-very-very-very-very-very-very-long-path.json" with { type:
  "json" };

// Prettier 3.3.1
import something from "./some-very-very-very-very-very-very-very-very-long-path.json" with { type: "json" };

3.3.0

diff

πŸ”— Release Notes

3.2.5

diff

Support Angular inline styles as single template literal (#15968 by @sosukesuzuki)

Angular v17 supports single string inline styles.

// Input
@Component({
  template: `<div>...</div>`,
  styles: `h1 { color: blue; }`,
})
export class AppComponent {}

// Prettier 3.2.4
@Component({
  template: `<div>...</div>`,
  styles: `h1 { color: blue; }`,
})
export class AppComponent {}

// Prettier 3.2.5
@Component({
  template: `<div>...</div>`,
  styles: `
    h1 {
      color: blue;
    }
  `,
})
export class AppComponent {}

Unexpected embedded formatting for Angular template (#15969 by @JounQin)

Computed template should not be considered as Angular component template

// Input
const template = "foobar";

@Component({
  [template]: `<h1>{{       hello }}</h1>`,
})
export class AppComponent {}

// Prettier 3.2.4
const template = "foobar";

@Component({
  [template]: `<h1>{{ hello }}</h1>`,
})
export class AppComponent {}

// Prettier 3.2.5
const template = "foobar";

@Component({
  [template]: `<h1>{{       hello }}</h1>`,
})
export class AppComponent {}

Use "json" parser for tsconfig.json by default (#16012 by @sosukesuzuki)

In v3.2.0, we introduced "jsonc" parser which adds trailing comma by default.

When adding a new parser we also define how it will be used based on the linguist-languages data.

tsconfig.json is a special file used by TypeScript, it uses .json file extension, but it actually uses the JSON with Comments syntax. However, we found that there are many third-party tools not recognize it correctly because of the confusing .json file extension.

We decide to treat it as a JSON file for now to avoid the extra configuration step.

To keep using the "jsonc" parser for your tsconfig.json files, add the following to your .prettierrc file

{
  "overrides": [
    {
      "files": ["tsconfig.json", "jsconfig.json"],
      "options": {
        "parser": "jsonc"
      }
    }
  ]
}
# Prettier 3.2.4
prettier --file-info tsconfig.json
{ "ignored": false, "inferredParser": "jsonc" }

# Prettier 3.2.5
prettier --file-info tsconfig.json
{ "ignored": false, "inferredParser": "json" }

3.2.4

diff

Fix incorrect parser inference (#15947 by @fisker)

Files like .eslintrc.json were incorrectly formatted as JSONC files.

// Input
prettier --file-info .eslintrc.json
{ "ignored": false, "inferredParser": "jsonc" }

// Prettier 3.2.4
prettier --file-info .eslintrc.json
{ "ignored": false, "inferredParser": "json" }

3.2.3

diff

Throw errors for invalid code (#15881 by @fisker, @Josh-Cena, @auvred)

// Input
1++;

// Prettier 3.2.2
1++;

// Prettier 3.2.3
SyntaxError: Invalid left-hand side expression in unary operation (1:1)
> 1 | 1++;
    | ^
// Input
try {} catch (error = 1){}

// Prettier 3.2.2
try {
} catch (error) {}

// Prettier 3.2.3
SyntaxError: Catch clause variable cannot have an initializer. (1:23)
> 1 | try {} catch (error = 1){}
    |                       ^

Fix parser inference (#15927 by @fisker)

// Prettier 3.2.2
prettier --file-info tsconfig.json
{ "ignored": false, "inferredParser": "json" }

// Prettier 3.2.3
prettier --file-info tsconfig.json
{ "ignored": false, "inferredParser": "jsonc" }

3.2.2

diff

Fix crash when parsing template literal CSS in a JSX style tag using a spread attribute (#15896 by @eelco)

For example this code would crash before:

<style {...spread}>{`.{}`}</style>

Fix formatting error on optional call expression and member chain (#15920 by @sosukesuzuki)

// Input
a(() => {}, c?.d());

// Prettier 3.2.1
TypeError: Cannot read properties of undefined (reading 'type')

// Prettier 3.2.2
a(() => {}, c?.d());

3.2.1

diff

Fix formatting error on member chain (#15915 by @sosukesuzuki)

// Input
test().test2().test2(thing?.something);

// Prettier 3.2.0
TypeError: Cannot read properties of undefined (reading 'type')

// Prettier 3.2.1
test().test2().test2(thing?.something);

3.2.0

diff

πŸ”— Release Notes

3.1.1

diff

Fix config file search (#15363 by @fisker)

Previously, we start search for config files from the filePath as a directory, if it happened to be a directory and contains config file, it will be used by mistake.

β”œβ”€ .prettierrc
└─ test.js         (A directory)
  └─ .prettierrc
// Prettier 3.1.0
await prettier.resolveConfigFile(new URL("./test.js", import.meta.url));
// <CWD>/test.js/.prettierrc

// Prettier 3.1.1
await prettier.resolveConfigFile(new URL("./test.js", import.meta.url));
// <CWD>/.prettierrc

Skip explicitly passed symbolic links with --no-error-on-unmatched-pattern (#15533 by @sanmai-NL)

Since Prettier v3, we stopped following symbolic links, however in some use cases, the symbolic link patterns can't be filtered out, and there is no way to prevent Prettier from throwing errors.

In Prettier 3.1.1, you can use --no-error-on-unmatched-pattern to simply skip symbolic links.

Consistently use tabs in ternaries when useTabs is true (#15662 by @auvred)

// Input
aaaaaaaaaaaaaaa
	? bbbbbbbbbbbbbbbbbb
	: ccccccccccccccc
	  ? ddddddddddddddd
	  : eeeeeeeeeeeeeee
	    ? fffffffffffffff
	    : gggggggggggggggg;

// Prettier 3.1.0
aaaaaaaaaaaaaaa
	? bbbbbbbbbbbbbbbbbb
	: ccccccccccccccc
	  ? ddddddddddddddd
	  : eeeeeeeeeeeeeee
	    ? fffffffffffffff
	    : gggggggggggggggg;

// Prettier 3.1.1
aaaaaaaaaaaaaaa
	? bbbbbbbbbbbbbbbbbb
	: ccccccccccccccc
		? ddddddddddddddd
		: eeeeeeeeeeeeeee
			? fffffffffffffff
			: gggggggggggggggg;

Improve config file search (#15663 by @fisker)

The Prettier config file search performance has been improved by more effective cache strategy.

Fix unstable and ugly formatting for comments in destructuring patterns (#15708 by @sosukesuzuki)

// Input
const {
  foo,
  // bar
  // baz
}: Foo = expr;

// Prettier 3.1.0
const {
  foo1,
} // bar
// baz
: Foo = expr;

// Prettier 3.1.0 second output
const {
  foo1, // bar
} // baz
: Foo = expr;

// Prettier 3.1.1
const {
  foo1,
  // bar
  // baz
}: Foo = expr;

Support "Import Attributes" (#15718 by @fisker)

TypeScript 5.3 supports the latest updates to the import attributes proposal.

import something from "./something.json" with { type: "json" };

Fix false claim in docs that cursorOffset is incompatible with rangeStart/rangeEnd (#15750 by @ExplodingCabbage)

The cursorOffset option has in fact been compatible with rangeStart/rangeEnd for over 5 years, thanks to work by @ds300. However, Prettier's documentation (including the CLI --help text) continued to claim otherwise, falsely. The documentation is now fixed.

Keep curly braces and from keyword in empty import statements (#15756 by @fisker)

// Input
import { } from 'foo';
import { /* comment */ } from 'bar';

// Prettier 3.1.0
import {} from "foo";
import /* comment */ "bar";

// Prettier 3.1.1
import {} from "foo";
import {} from /* comment */ "bar";

Keep empty import attributes and assertions (#15757 by @fisker)

// Input
import foo from "foo" with {};
import bar from "bar" assert {};

// Prettier 3.1.0
import foo from "foo";
import bar from "bar";

// Prettier 3.1.1
import foo from "foo" with {};
import bar from "bar" assert {};

3.1.0

diff

πŸ”— Release Notes

3.0.3

diff

Add preferUnplugged: true to package.json (#15169 by @fisker and @so1ve)

Prettier v3 uses dynamic imports, user will need to unplug Prettier when Yarn's PnP mode is enabled, add preferUnplugged: true to package.json, so Yarn will install Prettier as unplug by default.

Support shared config that forbids require() (#15233 by @fisker)

If an external shared config package is used, and the package exports don't have require or default export.

In Prettier 3.0.2 Prettier fails when attempt to require() the package, and throws an error.

Error [ERR_PACKAGE_PATH_NOT_EXPORTED]: No "exports" main defined in <packageName>/package.json

Allow argument of require() to break (#15256 by @fisker)

// Input
const plugin = require(
  global.STANDALONE
    ? path.join(__dirname, "../standalone.js")
    : path.join(__dirname, "..")
);

// Prettier 3.0.2
const plugin = require(global.STANDALONE
  ? path.join(__dirname, "../standalone.js")
  : path.join(__dirname, ".."));

// Prettier 3.0.3
const plugin = require(
  global.STANDALONE
    ? path.join(__dirname, "../standalone.js")
    : path.join(__dirname, "..")
);

Do not print trailing commas in arrow function type parameter lists in ts code blocks (#15286 by @sosukesuzuki)

<!-- Input -->
```ts
const foo = <T>() => {}
```

<!-- Prettier 3.0.2 -->
```ts
const foo = <T,>() => {}
```

<!-- Prettier 3.0.3 -->
```ts
const foo = <T>() => {}
```

Support TypeScript 5.2 using / await using declaration (#15321 by @sosukesuzuki)

Support for the upcoming Explicit Resource Management feature in ECMAScript. using / await using declaration

{
   using foo = new Foo();
   await using bar = new Bar();
}

3.0.2

diff

Break after = of assignment if RHS is poorly breakable AwaitExpression or YieldExpression (#15204 by @seiyab)

// Input
const { section, rubric, authors, tags } = await utils.upsertCommonData(mainData);

// Prettier 3.0.1
const { section, rubric, authors, tags } = await utils.upsertCommonData(
  mainData,
);

// Prettier 3.0.2
const { section, rubric, authors, tags } =
  await utils.upsertCommonData(mainData);

Do not add trailing comma for grouped scss comments (#15217 by @auvred)

/* Input */
$foo: (
	'property': (),
	// comment 1
	// comment 2
)

/* Prettier 3.0.1 */
$foo: (
  "property": (),
  // comment 1
  // comment 2,
);

/* Prettier 3.0.2 */
$foo: (
  "property": (),
  // comment 1
  // comment 2
);

Print declare and export keywords for nested namespace (#15249 by @sosukesuzuki)

// Input
declare namespace abc1.def {}
export namespace abc2.def {}

// Prettier 3.0.1
namespace abc1.def {}
namespace abc2.def {}

// Prettier 3.0.2
declare namespace abc1.def {}
export namespace abc2.def {}

3.0.1

diff

Fix cursor positioning for a special case (#14812 by @fisker)

// <|> is the cursor position

/* Input */
// All messages are represented in JSON.
// So, the prettier.py controls a subprocess which spawns "node {this_file}".
import {<|>  } from "fs"

/* Prettier 3.0.0 */
// All messages are represented in JSON.
// So, the prettier.py <|>controls a subprocess which spawns "node {this_file}".
import {} from "fs"

/* Prettier 3.0.1 */
// All messages are represented in JSON.
// So, the prettier.py controls a subprocess which spawns "node {this_file}".
import {<|>} from "fs"

Fix plugins/estree.d.ts to make it a module (#15018 by @kingyue737)

Add export {} in plugins/estree.d.ts to fix the "File is not a module" error

Add parenthesis around leading multiline comment in return statement (#15037 by @auvred)

// Input
function fn() {
  return (
    /**
     * @type {...}
     */ expression
  )
}

// Prettier 3.0.0
function fn() {
  return /**
   * @type {...}
   */ expression;
}

// Prettier 3.0.1
function fn() {
  return (
    /**
     * @type {...}
     */ expression
  );
}

Add support for Vue "Generic Components" (#15066 by @auvred)

https://blog.vuejs.org/posts/vue-3-3#generic-components

<!-- Input -->
<script setup lang="ts" generic="T extends Type1 & Type2 & (Type3 | Type4), U extends string | number | boolean"></script>

<!-- Prettier 3.0.0 -->
<script
  setup
  lang="ts"
  generic="T extends Type1 & Type2 & (Type3 | Type4), U extends string | number | boolean"
></script>

<!-- Prettier 3.0.1 -->
<script
  setup
  lang="ts"
  generic="
    T extends Type1 & Type2 & (Type3 | Type4),
    U extends string | number | boolean
  "
></script>

Fix comments print in IfStatement (#15076 by @fisker)

function a(b) {
  if (b) return 1; // comment
  else return 2;
}

/* Prettier 3.0.0 */
Error: Comment "comment" was not printed. Please report this error!

/* Prettier 3.0.1 */
function a(b) {
  if (b) return 1; // comment
  else return 2;
}

Add missing type definition for printer.preprocess (#15123 by @so1ve)

export interface Printer<T = any> {
  // ...
+ preprocess?:
+   | ((ast: T, options: ParserOptions<T>) => T | Promise<T>)
+   | undefined;
}

Add missing getVisitorKeys method type definition for Printer (#15125 by @auvred)

const printer: Printer = {
  print: () => [],
  getVisitorKeys(node, nonTraversableKeys) {
    return ["body"];
  },
};

Add typing to support readonly array properties of AST Node (#15127 by @auvred)

// Input
interface TestNode {
  readonlyArray: readonly string[];
}

declare const path: AstPath<TestNode>;

path.map(() => "", "readonlyArray");

// Prettier 3.0.0
interface TestNode {
  readonlyArray: readonly string[];
}

declare const path: AstPath<TestNode>;

path.map(() => "", "readonlyArray");
//                  ^ Argument of type '"readonlyArray"' is not assignable to parameter of type '"regularArray"'. ts(2345)

// Prettier 3.0.1
interface TestNode {
  readonlyArray: readonly string[];
}

declare const path: AstPath<TestNode>;

path.map(() => "", "readonlyArray");

Add space before unary minus followed by a function call (#15129 by @pamelalozano)

// Input
div {
  margin: - func();
}

// Prettier 3.0.0
div {
  margin: -func();
}

// Prettier 3.0.1
div {
  margin: - func();
}

3.0.0

diff

πŸ”— Release Notes

2.8.8

This version is a republished version of v2.8.7. A bad version was accidentally published and it can't be unpublished, apologies for the churn.

2.8.7

diff

Allow multiple decorators on same getter/setter (#14584 by @fisker)

// Input
class A {
  @decorator()
  get foo () {}
  
  @decorator()
  set foo (value) {}
}

// Prettier 2.8.6
SyntaxError: Decorators cannot be applied to multiple get/set accessors of the same name. (5:3)
  3 |   get foo () {}
  4 |   
> 5 |   @decorator()
    |   ^^^^^^^^^^^^
  6 |   set foo (value) {}
  7 | }

// Prettier 2.8.7
class A {
  @decorator()
  get foo() {}

  @decorator()
  set foo(value) {}
}

2.8.6

diff

Allow decorators on private members and class expressions (#14548 by @fisker)

// Input
class A {
  @decorator()
  #privateMethod () {}
}

// Prettier 2.8.5
SyntaxError: Decorators are not valid here. (2:3)
  1 | class A {
> 2 |   @decorator()
    |   ^^^^^^^^^^^^
  3 |   #privateMethod () {}
  4 | }

// Prettier 2.8.6
class A {
  @decorator()
  #privateMethod() {}
}

2.8.5

diff

Support TypeScript 5.0 (#14391 by @fisker, #13819 by @fisker, @sosukesuzuki)

TypeScript 5.0 introduces two new syntactic features:

  • const modifiers for type parameters
  • export type * declarations

Add missing parentheses for decorator (#14393 by @fisker)

// Input
class Person {
  @(myDecoratorArray[0])
  greet() {}
}

// Prettier 2.8.4
class Person {
  @myDecoratorArray[0]
  greet() {}
}

// Prettier 2.8.5
class Person {
  @(myDecoratorArray[0])
  greet() {}
}

Add parentheses for TypeofTypeAnnotation to improve readability (#14458 by @fisker)

// Input
type A = (typeof node.children)[];

// Prettier 2.8.4
type A = typeof node.children[];

// Prettier 2.8.5
type A = (typeof node.children)[];

Support max_line_length=off when parsing .editorconfig (#14516 by @josephfrazier)

If an .editorconfig file is in your project and it sets max_line_length=off for the file you're formatting, it will be interpreted as a printWidth of Infinity rather than being ignored (which previously resulted in the default printWidth of 80 being applied, if not overridden by Prettier-specific configuration).

<!-- Input -->
<div className='HelloWorld' title={`You are visitor number ${ num }`} onMouseOver={onMouseOver}/>

<!-- Prettier 2.8.4 -->
<div
  className="HelloWorld"
  title={`You are visitor number ${num}`}
  onMouseOver={onMouseOver}
/>;

<!-- Prettier 2.8.5 -->
<div className="HelloWorld" title={`You are visitor number ${num}`} onMouseOver={onMouseOver} />;

2.8.4

diff

Fix leading comments in mapped types with readonly (#13427 by @thorn0, @sosukesuzuki)

// Input
type Type = {
  // comment
  readonly [key in Foo];
};

// Prettier 2.8.3
type Type = {
  readonly // comment
  [key in Foo];
};

// Prettier 2.8.4
type Type = {
  // comment
  readonly [key in Foo];
};

Group params in opening block statements (#14067 by @jamescdavis)

This is a follow-up to #13930 to establish wrapping consistency between opening block statements and else blocks by grouping params in opening blocks. This causes params to break to a new line together and not be split across lines unless the length of params exceeds the print width. This also updates the else block wrapping to behave exactly the same as opening blocks.

{{! Input }}
{{#block param param param param param param param param param param as |blockParam|}}
  Hello
{{else block param param param param param param param param param param as |blockParam|}}
  There
{{/block}}

{{! Prettier 2.8.3 }}
{{#block
  param
  param
  param
  param
  param
  param
  param
  param
  param
  param
  as |blockParam|
}}
  Hello
{{else block param
param
param
param
param
param
param
param
param
param}}
  There
{{/block}}

{{! Prettier 2.8.4 }}
{{#block
  param param param param param param param param param param
  as |blockParam|
}}
  Hello
{{else block
  param param param param param param param param param param
  as |blockParam|
}}
  There
{{/block}}

Ignore files in .sl/ (#14206 by @bolinfest)

In Sapling SCM, .sl/ is the folder where it stores its state, analogous to .git/ in Git. It should be ignored in Prettier like the other SCM folders.

Recognize @satisfies in Closure-style type casts (#14262 by @fisker)

// Input
const a = /** @satisfies {Record<string, string>} */ ({hello: 1337});
const b = /** @type {Record<string, string>} */ ({hello: 1337});

// Prettier 2.8.3
const a = /** @satisfies {Record<string, string>} */ { hello: 1337 };
const b = /** @type {Record<string, string>} */ ({ hello: 1337 });

// Prettier 2.8.4
const a = /** @satisfies {Record<string, string>} */ ({hello: 1337});
const b = /** @type {Record<string, string>} */ ({hello: 1337});

Fix parens in inferred function return types with extends (#14279 by @fisker)

// Input
type Foo<T> = T extends ((a) => a is infer R extends string) ? R : never;

// Prettier 2.8.3 (First format)
type Foo<T> = T extends (a) => a is infer R extends string ? R : never;

// Prettier 2.8.3 (Second format)
SyntaxError: '?' expected. 

// Prettier 2.8.4
type Foo<T> = T extends ((a) => a is infer R extends string) ? R : never;

2.8.3

diff

Allow self-closing tags on custom elements (#14170 by @fisker)

See Angular v15.1.0 release note for details.

// Input
<app-test/>

// Prettier 2.8.2
SyntaxError: Only void and foreign elements can be self closed "app-test" (1:1)
> 1 | <app-test/>
    | ^^^^^^^^^
  2 |

// Prettier 2.8.3
<app-test />

2.8.2

diff

Don't lowercase link references (#13155 by @DerekNonGeneric & @fisker)

<!-- Input -->
We now don't strictly follow the release notes format suggested by [Keep a Changelog].

[Keep a Changelog]: https://example.com/

<!-- Prettier 2.8.1 -->
We now don't strictly follow the release notes format suggested by [Keep a Changelog].

[keep a changelog]: https://example.com/
<!--
^^^^^^^^^^^^^^^^^^ lowercased
-->

<!-- Prettier 2.8.2 -->
<Same as input>

Preserve self-closing tags (#13691 by @dcyriller)

{{! Input }}
<div />
<div></div>
<custom-component />
<custom-component></custom-component>
<i />
<i></i>
<Component />
<Component></Component>

{{! Prettier 2.8.1 }}
<div></div>
<div></div>
<custom-component></custom-component>
<custom-component></custom-component>
<i></i>
<i></i>
<Component />
<Component />

{{! Prettier 2.8.2 }}
<div />
<div></div>
<custom-component />
<custom-component></custom-component>
<i />
<i></i>
<Component />
<Component />

Allow custom "else if"-like blocks with block params (#13930 by @jamescdavis)

#13507 added support for custom block keywords used with else, but failed to allow block params. This updates printer-glimmer to allow block params with custom "else if"-like blocks.

{{! Input }}
{{#when isAtWork as |work|}}
  Ship that
  {{work}}!
{{else when isReading as |book|}}
  You can finish
  {{book}}
  eventually...
{{else}}
  Go to bed!
{{/when}}

{{! Prettier 2.8.1 }}
{{#when isAtWork as |work|}}
  Ship that
  {{work}}!
{{else when isReading}}
  You can finish
  {{book}}
  eventually...
{{else}}
  Go to bed!
{{/when}}

{{! Prettier 2.8.2 }}
{{#when isAtWork as |work|}}
  Ship that
  {{work}}!
{{else when isReading as |book|}}
  You can finish
  {{book}}
  eventually...
{{else}}
  Go to bed!
{{/when}}

Preserve empty lines between nested SCSS maps (#13931 by @jneander)

/* Input */
$map: (
  'one': (
     'key': 'value',
  ),

  'two': (
     'key': 'value',
  ),
)

/* Prettier 2.8.1 */
$map: (
  'one': (
     'key': 'value',
  ),
  'two': (
     'key': 'value',
  ),
)

/* Prettier 2.8.2 */
$map: (
  'one': (
     'key': 'value',
  ),

  'two': (
     'key': 'value',
  ),
)

Fix missing parentheses when an expression statement starts with let[ (#14000, #14044 by @fisker, @thorn0)

// Input
(let[0] = 2);

// Prettier 2.8.1
let[0] = 2;

// Prettier 2.8.1 (second format)
SyntaxError: Unexpected token (1:5)
> 1 | let[0] = 2;
    |     ^
  2 |

// Prettier 2.8.2
(let)[0] = 2;

Fix semicolon duplicated at the end of LESS file (#14007 by @mvorisek)

// Input
@variable: {
  field: something;
};

// Prettier 2.8.1
@variable: {
  field: something;
}; ;

// Prettier 2.8.2
@variable: {
  field: something;
};

Fix no space after unary minus when followed by opening parenthesis in LESS (#14008 by @mvorisek)

// Input
.unary_minus_single {
  margin: -(@a);
}

.unary_minus_multi {
  margin: 0 -(@a);
}

.binary_minus {
  margin: 0 - (@a);
}

// Prettier 2.8.1
.unary_minus_single {
  margin: - (@a);
}

.unary_minus_multi {
  margin: 0 - (@a);
}

.binary_minus {
  margin: 0 - (@a);
}

// Prettier 2.8.2
.unary_minus_single {
  margin: -(@a);
}

.unary_minus_multi {
  margin: 0 -(@a);
}

.binary_minus {
  margin: 0 - (@a);
}

Do not change case of property name if inside a variable declaration in LESS (#14034 by @mvorisek)

// Input
@var: {
  preserveCase: 0;
};

// Prettier 2.8.1
@var: {
  preservecase: 0;
};

// Prettier 2.8.2
@var: {
  preserveCase: 0;
};

Fix formatting for auto-accessors with comments (#14038 by @fisker)

// Input
class A {
  @dec()
  // comment
  accessor b;
}

// Prettier 2.8.1
class A {
  @dec()
  accessor // comment
  b;
}

// Prettier 2.8.1 (second format)
class A {
  @dec()
  accessor; // comment
  b;
}

// Prettier 2.8.2
class A {
  @dec()
  // comment
  accessor b;
}

Add parentheses for TSTypeQuery to improve readability (#14042 by @onishi-kohei)

// Input
a as (typeof node.children)[number]
a as (typeof node.children)[]
a as ((typeof node.children)[number])[]

// Prettier 2.8.1
a as typeof node.children[number];
a as typeof node.children[];
a as typeof node.children[number][];

// Prettier 2.8.2
a as (typeof node.children)[number];
a as (typeof node.children)[];
a as (typeof node.children)[number][];

Fix displacing of comments in default switch case (#14047 by @thorn0)

It was a regression in Prettier 2.6.0.

// Input
switch (state) {
  default:
    result = state; // no change
    break;
}

// Prettier 2.8.1
switch (state) {
  default: // no change
    result = state;
    break;
}

// Prettier 2.8.2
switch (state) {
  default:
    result = state; // no change
    break;
}

Support type annotations on auto accessors via babel-ts (#14049 by @sosukesuzuki)

The bug that @babel/parser cannot parse auto accessors with type annotations has been fixed. So we now support it via babel-ts parser.

class Foo {
  accessor prop: number;
}

Fix formatting of empty type parameters (#14073 by @fisker)

// Input
const foo: bar</* comment */> = () => baz;

// Prettier 2.8.1
Error: Comment "comment" was not printed. Please report this error!

// Prettier 2.8.2
const foo: bar</* comment */> = () => baz;

Add parentheses to head of ExpressionStatement instead of the whole statement (#14077 by @fisker)

// Input
({}).toString.call(foo) === "[object Array]"
  ? foo.forEach(iterateArray)
  : iterateObject(foo);

// Prettier 2.8.1
({}.toString.call(foo) === "[object Array]"
  ? foo.forEach(iterateArray)
  : iterateObject(foo));

// Prettier 2.8.2
({}).toString.call(foo.forEach) === "[object Array]"
  ? foo.forEach(iterateArray)
  : iterateObject(foo);

Fix comments after directive (#14081 by @fisker)

// Input
"use strict" /* comment */;

// Prettier 2.8.1 (with other js parsers except `babel`)
Error: Comment "comment" was not printed. Please report this error!

// Prettier 2.8.2
<Same as input>

Fix formatting for comments inside JSX attribute (#14082 by @fisker)

// Input
function MyFunctionComponent() {
  <button label=/*old*/"new">button</button>
}

// Prettier 2.8.1
Error: Comment "old" was not printed. Please report this error!

// Prettier 2.8.2
function MyFunctionComponent() {
  <button label=/*old*/ "new">button</button>;
}

Quote numeric keys for json-stringify parser (#14083 by @fisker)

// Input
{0: 'value'}

// Prettier 2.8.1
{
  0: "value"
}

// Prettier 2.8.2
{
  "0": "value"
}

Fix removing commas from function arguments in maps (#14089 by @sosukesuzuki)

/* Input */
$foo: map-fn(
  (
    "#{prop}": inner-fn($first, $second),
  )
);

/* Prettier 2.8.1 */
$foo: map-fn(("#{prop}": inner-fn($first $second)));

/* Prettier 2.8.2 */
$foo: map-fn(
  (
    "#{prop}": inner-fn($first, $second),
  )
);

Do not insert space in LESS property access (#14103 by @fisker)

// Input
a {
  color: @colors[@white];
}

// Prettier 2.8.1
a {
  color: @colors[ @white];
}

// Prettier 2.8.2
<Same as input>

2.8.1

diff

Fix SCSS map in arguments (#9184 by @agamkrbit)

// Input
$display-breakpoints: map-deep-merge(
  (
    "print-only": "only print",
    "screen-only": "only screen",
    "xs-only": "only screen and (max-width: #{map-get($grid-breakpoints, "sm")-1})",
  ),
  $display-breakpoints
);

// Prettier 2.8.0
$display-breakpoints: map-deep-merge(
  (
    "print-only": "only print",
    "screen-only": "only screen",
    "xs-only": "only screen and (max-width: #{map-get($grid-breakpoints, " sm
      ")-1})",
  ),
  $display-breakpoints
);

// Prettier 2.8.1
$display-breakpoints: map-deep-merge(
  (
    "print-only": "only print",
    "screen-only": "only screen",
    "xs-only": "only screen and (max-width: #{map-get($grid-breakpoints, "sm")-1})",
  ),
  $display-breakpoints
);

Support auto accessors syntax (#13919 by @sosukesuzuki)

Support for Auto Accessors Syntax landed in TypeScript 4.9.

(Doesn't work well with babel-ts parser)

class Foo {
  accessor foo: number = 3;
}

2.8.0

diff

πŸ”— Release Notes

2.7.1

diff

Keep useful empty lines in description (#13013 by @chimurai)

# Input
"""
First line

Second Line
"""
type Person {
  name: String
}

# Prettier 2.7.0
"""
First line
Second Line
"""
type Person {
  name: String
}


# Prettier 2.7.1
"""
First line

Second Line
"""
type Person {
  name: String
}

2.7.0

diff

πŸ”— Release Notes

2.6.2

diff

Fix LESS/SCSS format error (#12536 by @fisker)

// Input
.background-gradient(@cut) {
    background: linear-gradient(
        to right,
        @white 0%,
        @white (@cut - 0.01%),
        @portal-background @cut,
        @portal-background 100%
    );
}

// Prettier 2.6.1
TypeError: Cannot read properties of undefined (reading 'endOffset')

// Prettier 2.6.2
.background-gradient(@cut) {
  background: linear-gradient(
    to right,
    @white 0%,
    @white (@cut - 0.01%),
    @portal-background @cut,
    @portal-background 100%
  );
}

Update meriyah to fix several bugs (#12567 by @fisker, fixes in meriyah by @3cp)

Fixes bugs when parsing following valid code:

foo(await bar());
const regex = /.*/ms;
const element = <p>{/w/.test(s)}</p>;
class A extends B {
  #privateMethod() {
    super.method();
  }
}

2.6.1

diff

Ignore loglevel when printing information (#12477 by @fisker)

# Prettier 2.6.0
prettier --loglevel silent --find-config-path index.js
# Nothing printed

# Prettier 2.6.1
prettier --loglevel silent --help no-color
# .prettierrc

Make artifact friendly for webpack (#12485, #12511 by @fisker)

Fixes two problems when bundling our UMD files with webpack:

  • A error "`....__exportStar` is not a function" throws when running the bundles.
  • Some files cause warning about "Critical dependency: the request of a dependency is an expression".

Fix non-idempotent formatting of function calls with complex type arguments (#12508 by @sosukesuzuki)

// Input
const foo =
  doSomething<{ foo1: "foo1", foo2: "foo2", foo3: "foo3", foo4: "foo4", foo5: "foo5" }>();

// Prettier 2.6.0 (first)
const foo =
  doSomething<{
    foo1: "foo1";
    foo2: "foo2";
    foo3: "foo3";
    foo4: "foo4";
    foo5: "foo5";
  }>();

// Prettier 2.6.0 (second)
const foo = doSomething<{
  foo1: "foo1";
  foo2: "foo2";
  foo3: "foo3";
  foo4: "foo4";
  foo5: "foo5";
}>();

// Prettier 2.6.1
const foo = doSomething<{
  foo1: "foo1";
  foo2: "foo2";
  foo3: "foo3";
  foo4: "foo4";
  foo5: "foo5";
}>();

Fix minimist security issue (#12513 by @dependabot)

Details: Prototype Pollution

2.6.0

diff

πŸ”— Release Notes

2.5.1

diff

Improve formatting for empty tuple types (#11884 by @sosukesuzuki)

// Input
type Foo =
  Foooooooooooooooooooooooooooooooooooooooooooooooooooooooooo extends []
    ? Foo3
    : Foo4;

// Prettier 2.5.0
type Foo = Foooooooooooooooooooooooooooooooooooooooooooooooooooooooooo extends [

]
  ? Foo3
  : Foo4;

// Prettier 2.5.0 (tailingCommma = all)
// Invalid TypeScript code
type Foo = Foooooooooooooooooooooooooooooooooooooooooooooooooooooooooo extends [
  ,
]
  ? Foo3
  : Foo4;

// Prettier 2.5.1
type Foo =
  Foooooooooooooooooooooooooooooooooooooooooooooooooooooooooo extends []
    ? Foo3
    : Foo4;

Fix compatibility with Jest inline snapshot test (#11892 by @fisker)

A internal change in [email protected] accidentally breaks the Jest inline snapshot test.

Support Glimmer's named blocks (#11899 by @duailibe)

Prettier already supported this feature, but it converted empty named blocks to self-closing, which is not supported by the Glimmer compiler.

See: Glimmer's named blocks.

// Input
<Component>
  <:named></:named>
</Component>

// Prettier 2.5.0
<Component>
  <:named />
</Component>

// Prettier 2.5.1
<Component>
  <:named></:named>
</Component>

2.5.0

diff

πŸ”— Release Notes

2.4.1

diff

Fix wildcard syntax in @forward (#11482) (#11487 by @niksy)

// Input
@forward "library" as btn-*;

// Prettier 2.4.0
@forward "library" as btn- *;

// Prettier 2.4.1
@forward "library" as btn-*;

Add new CLI option debug-print-ast (#11514 by @sosukesuzuki)

A new --debug-print-ast CLI flag for debugging.

2.4.0

diff

πŸ”— Release Notes

2.3.2

diff

Fix failure on dir with trailing slash (#11000 by @fisker)

$ ls
1.js  1.unknown

# Prettier 2.3.1
$ prettier . -l
1.js
$ prettier ./ -l
[error] No supported files were found in the directory: "./".

# Prettier 2.3.2
$ prettier ./ -l
1.js

Fix handling of parenthesis with Flow's {Optional}IndexedAccess (#11051 by @gkz)

Add parens when required.

// Input
type A = (T & S)['bar'];
type B = (T | S)['bar'];
type C = (?T)['bar'];
type D = (typeof x)['bar'];
type E = (string => void)['bar'];

// Prettier 2.3.1
type A = T & S["bar"];
type B = T | S["bar"];
type C = ?T["bar"];
type D = typeof x["bar"];
type E = (string) => void["bar"];

// Prettier 2.3.2
type A = (T & S)["bar"];
type B = (T | S)["bar"];
type C = (?T)["bar"];
type D = (typeof x)["bar"];
type E = ((string) => void)["bar"];

Print override modifiers for parameter property (#11074 by @sosukesuzuki)

// Input
class D extends B {
  constructor(override foo: string) {
    super();
  }
}

// Prettier 2.3.1
class D extends B {
  constructor(foo: string) {
    super();
  }
}

// Prettier 2.3.2
class D extends B {
  constructor(override foo: string) {
    super();
  }
}

2.3.1

diff

Support TypeScript 4.3 (#10945 by @sosukesuzuki)

class Foo extends  {
  override method() {}
}
class Foo {
  static [key: string]: Bar;
}
interface Foo {
  set foo(value);
  get foo(): string;
}

Preserve attributes order for element node (#10958 by @dcyriller)

{{!-- Input --}}
<MyComponent
  {{! this is a comment for arg 1}}
  @arg1="hello"
  {{on "click" this.modify}}
  @arg2="hello"
  {{! this is a comment for arg 3}}
  @arg3="hello"
  @arg4="hello"
  {{! this is a comment for arg 5}}
  @arg5="hello"
  ...arguments
/>
{{!-- Prettier stable --}}
<MyComponent
  @arg1="hello"
  @arg2="hello"
  @arg3="hello"
  @arg4="hello"
  @arg5="hello"
  ...arguments
  {{on "click" this.modify}}
  {{! this is a comment for arg 1}}
  {{! this is a comment for arg 3}}
  {{! this is a comment for arg 5}}
/>
{{!-- Prettier main --}}
<MyComponent
  {{! this is a comment for arg 1}}
  @arg1="hello"
  {{on "click" this.modify}}
  @arg2="hello"
  {{! this is a comment for arg 3}}
  @arg3="hello"
  @arg4="hello"
  {{! this is a comment for arg 5}}
  @arg5="hello"
  ...arguments
/>

Track cursor position properly when it’s at the end of the range to format (#10938 by @j-f1)

Previously, if the cursor was at the end of the range to format, it would simply be placed back at the end of the updated range. Now, it will be repositioned if Prettier decides to add additional code to the end of the range (such as a semicolon).

// Input (<|> represents the cursor)
const someVariable = myOtherVariable<|>
// range to format:  ^^^^^^^^^^^^^^^

// Prettier stable
const someVariable = myOtherVariable;<|>
// range to format:  ^^^^^^^^^^^^^^^

// Prettier main
const someVariable = myOtherVariable<|>;
// range to format:  ^^^^^^^^^^^^^^^

Break the LHS of type alias that has complex type parameters (#10901 by @sosukesuzuki)

// Input
type FieldLayoutWith<
  T extends string,
  S extends unknown = { width: string }
> = {
  type: T;
  code: string;
  size: S;
};

// Prettier stable
type FieldLayoutWith<T extends string, S extends unknown = { width: string }> =
  {
    type: T;
    code: string;
    size: S;
  };

// Prettier main
type FieldLayoutWith<
  T extends string,
  S extends unknown = { width: string }
> = {
  type: T;
  code: string;
  size: S;
};

Break the LHS of assignments that has complex type parameters (#10916 by @sosukesuzuki)

// Input
const map: Map<
  Function,
  Map<string | void, { value: UnloadedDescriptor }>
> = new Map();

// Prettier stable
const map: Map<Function, Map<string | void, { value: UnloadedDescriptor }>> =
  new Map();

// Prettier main
const map: Map<
  Function,
  Map<string | void, { value: UnloadedDescriptor }>
> = new Map();

Fix incorrectly wrapped arrow functions with return types (#10940 by @thorn0)

// Input
longfunctionWithCall12("bla", foo, (thing: string): complex<type<something>> => {
  code();
});

// Prettier stable
longfunctionWithCall12("bla", foo, (thing: string): complex<
  type<something>
> => {
  code();
});

// Prettier main
longfunctionWithCall12(
  "bla",
  foo,
  (thing: string): complex<type<something>> => {
    code();
  }
);

Avoid breaking call expressions after assignments with complex type arguments (#10949 by @sosukesuzuki)

// Input
const foo = call<{
  prop1: string;
  prop2: string;
  prop3: string;
}>();

// Prettier stable
const foo =
  call<{
    prop1: string;
    prop2: string;
    prop3: string;
  }>();

// Prettier main
const foo = call<{
  prop1: string;
  prop2: string;
  prop3: string;
}>();

Fix order of override modifiers (#10961 by @sosukesuzuki)

// Input
class Foo extends Bar {
  abstract override foo: string;
}

// Prettier stable
class Foo extends Bar {
  override abstract foo: string;
}

// Prettier main
class Foo extends Bar {
  abstract override foo: string;
}

2.3.0

diff

πŸ”— Release Notes

2.2.1

diff

Fix formatting for AssignmentExpression with ClassExpression (#9741 by @sosukesuzuki)

// Input
module.exports = class A extends B {
  method() {
    console.log("foo");
  }
};

// Prettier 2.2.0
module.exports = class A extends (
  B
) {
  method() {
    console.log("foo");
  }
};

// Prettier 2.2.1
module.exports = class A extends B {
  method() {
    console.log("foo");
  }
};

2.2.0

diff

πŸ”— Release Notes

2.1.2

diff

Fix formatting for directives in fields (#9116 by @sosukesuzuki)

# Input
type Query {
  someQuery(id: ID!, someOtherData: String!): String! @deprecated @isAuthenticated
  versions: Versions!
}


# Prettier stable
type Query {
  someQuery(id: ID!, someOtherData: String!): String!
  @deprecated
  @isAuthenticated
  versions: Versions!
}

# Prettier master
type Query {
  someQuery(id: ID!, someOtherData: String!): String!
    @deprecated
    @isAuthenticated
  versions: Versions!
}

Fix line breaks for CSS in JS (#9136 by @sosukesuzuki)

// Input
styled.div`
  // prettier-ignore
  @media (aaaaaaaaaaaaa) {
	z-index: ${(props) => (props.isComplete ? '1' : '0')};
  }
`;
styled.div`
  ${props => getSize(props.$size.xs)}
  ${props => getSize(props.$size.sm, 'sm')}
  ${props => getSize(props.$size.md, 'md')}
`;

// Prettier stable
styled.div`
  // prettier-ignore
  @media (aaaaaaaaaaaaa) {
	z-index: ${(props) =>
    props.isComplete ? "1" : "0"};
  }
`;
styled.div`
  ${(props) => getSize(props.$size.xs)}
  ${(props) => getSize(props.$size.sm, "sm")}
  ${(props) =>
    getSize(props.$size.md, "md")}
`;

// Prettier master
styled.div`
  // prettier-ignore
  @media (aaaaaaaaaaaaa) {
        z-index: ${(props) => (props.isComplete ? "1" : "0")};
  }
`;
styled.div`
  ${(props) => getSize(props.$size.xs)}
  ${(props) => getSize(props.$size.sm, "sm")}
  ${(props) => getSize(props.$size.md, "md")}
`;

Fix comment printing in mapping and sequence (#9143, #9169 by @sosukesuzuki, @fisker, fix in yaml-unist-parser by @ikatyang)

# Input
- a
  # Should indent
- bb

---
- a: a
  b: b

  # Should print one empty line before
- another

# Prettier stable
- a
# Should indent
- bb

---
- a: a
  b: b


  # Should print one empty line before
- another

# Prettier master
- a
  # Should indent
- bb

---
- a: a
  b: b

  # Should print one empty line before
- another

2.1.1

diff

Fix format on html with frontMatter (#9043 by @fisker)

<!-- Input -->
---
layout: foo
---

Test <a
href="https://prettier.io">abc</a>.

<!-- Prettier stable -->
TypeError: Cannot read property 'end' of undefined
  ...

<!-- Prettier master -->
---
layout: foo
---

Test <a href="https://prettier.io">abc</a>.

Fix broken format for ...infer T (#9044 by @fisker)

// Input
type Tail<T extends any[]> = T extends [infer U, ...infer R] ? R : never;

// Prettier stable
type Tail<T extends any[]> = T extends [infer U, ...(infer R)] ? R : never;

// Prettier master
type Tail<T extends any[]> = T extends [infer U, ...infer R] ? R : never;

Fix format on style[lang="sass"] (#9051 by @fisker)

<!-- Input -->
<style lang="sass">
.hero
  @include background-centered
</style>

<!-- Prettier stable -->
<style lang="sass">
.hero @include background-centered;
</style>

<!-- Prettier master -->
<style lang="sass">
  .hero
    @include background-centered
</style>

Fix self-closing blocks and blocks with src attribute format (#9052, #9055 by @fisker)

<!-- Input -->
<custom lang="markdown" src="./foo.md"></custom>
<custom lang="markdown" src="./foo.md" />
<custom lang="markdown" />

<!-- Prettier stable -->
<custom lang="markdown" src="./foo.md">

</custom>
<custom lang="markdown" src="./foo.md"

/>
<custom lang="markdown"

/>

<!-- Prettier master -->
<custom lang="markdown" src="./foo.md"></custom>
<custom lang="markdown" src="./foo.md" />
<custom lang="markdown" />

2.1.0

diff

πŸ”— Release Notes

2.0.5

diff

Less: Fix formatting of :extend (#7984 by @fisker)

// Input
.class {
  &:extend(.some-class .some-other-class .some-very-loooooooooooooong-class all);
}

// Prettier 2.0.4
.class {
  &:extend(
    .some-class .some-other-class .some-very-loooooooooooooong-class all
  );
}

// Prettier 2.0.4 (Second format)
.class {
  &: extend(
    .some-class .some-other-class .some-very-loooooooooooooong-class all
  );
}

// Prettier 2.0.5
.class {
  &:extend(
    .some-class .some-other-class .some-very-loooooooooooooong-class all
  );
}

Editor integration: Use resolve if builtin require.resolve is overridden (#8072 by @fisker)

This fixes issues that the users of Atom and WebStorm faced with 2.0.4.

Prettier now switches to using the resolve module for resolving configuration files and plugins if it detects that require.resolve isn't Node's builtin function (doesn't support the second argument), which happens in environments like editor extensions. To force the fallback, set the PRETTIER_FALLBACK_RESOLVE environment variable to true.

2.0.4

diff

Revert #7869, "[TypeScript] format TSAsExpression with same logic as BinaryExpression" (#7958)

2.0.3

diff

JavaScript

Fix prettier-ignore inside JSX (#7877 by @fisker)

// Input
<div>
{
  /* prettier-ignore */
  x     ?   <Y/> : <Z/>
}
</div>;

// Prettier 2.0.2 (first output)
<div>
  {/* prettier-ignore */
  x     ?   <Y/> : <Z/>}
</div>;

// Prettier 2.0.2 (second output)
<div>{/* prettier-ignore */ x     ?   <Y/> : <Z/>}</div>;

// Prettier 2.0.3
<div>
  {
    /* prettier-ignore */
    x     ?   <Y/> : <Z/>
  }
</div>;

Fix regressions in styled-components template literals (#7883 by @thorn0)

// Input
const Icon = styled.div`
  background:   var(--${background});
  ${Link}:not(:first-child) {
      fill:    rebeccapurple;
  }
`;

// Prettier 2.0.2
const Icon = styled.div`
  background: var(-- ${background});
  ${Link}:not (:first-child) {
    fill: rebeccapurple;
  }
`;

// Prettier 2.0.3
const Icon = styled.div`
  background: var(--${background});
  ${Link}:not(:first-child) {
    fill: rebeccapurple;
  }
`;

Fix: line endings were not always converted properly in multiline strings and comments (#7891 by @sidharthv96)

// Input
export const IAmIncredibleLongFunctionName = IAmAnotherFunctionName(<CRLF>
  (_0: IAmIncredibleLongParameterType) => {<CRLF>
    setTimeout(() => {<CRLF>
      /*<CRLF>
        Multiline comment<CRLF>
        Multiline comment<CRLF>
        Multiline comment<CRLF>
      */<CRLF>
      console.log(<CRLF>
        "Multiline string\<CRLF>
         Multiline string\<CRLF>
         Multiline string"<CRLF>
      );<CRLF>
    });<CRLF>
  }<CRLF>
);<CRLF>

// Prettier 2.0.2
export const IAmIncredibleLongFunctionName = IAmAnotherFunctionName(<CRLF>
  (_0: IAmIncredibleLongParameterType) => {<CRLF>
    setTimeout(() => {<CRLF>
      /*<LF>
        Multiline comment<LF>
        Multiline comment<LF>
        Multiline comment<LF>
      */<CRLF>
      console.log(<CRLF>
        "Multiline string\<LF>
         Multiline string\<LF>
         Multiline string"<CRLF>
      );<CRLF>
    });<CRLF>
  }<CRLF>
);<CRLF>

// Prettier 2.0.3: same as input

Fix bug with holes in array literals (#7911 by @bakkot)

// Input
new Test()
  .test()
  .test([, 0])
  .test();

// Prettier 2.0.2
[error] in.js: TypeError: Cannot read property 'type' of null

// Prettier 2.0.3
new Test().test().test([, 0]).test();

TypeScript

Wrap TSAsExpression (#7869 by @sosukesuzuki)

// Input
const value = thisIsAnIdentifier as ThisIsAReallyReallyReallyReallyReallyReallyReallyReallyReallyReallyReallyLongInterface;

// Prettier 2.0.2
const value = thisIsAnIdentifier as ThisIsAReallyReallyReallyReallyReallyReallyReallyReallyReallyReallyReallyLongInterface;

// Prettier 2.0.3
const value =
  thisIsAnIdentifier as
  ThisIsAReallyReallyReallyReallyReallyReallyReallyReallyReallyReallyReallyLongInterface;

Flow

Print dangling comments for inexact object type (#7892 by @sosukesuzuki)

// Input
type Foo = {
  // comment
  ...,
};

// Prettier 2.0.2
Error: Comment "comment" was not printed. Please report this error!

// Prettier 2.0.3
type Foo = {
  // comment
  ...,
};

Do not add comma for explicit inexact object with indexer property or no properties (#7923 by @DmitryGonchar)

// Input
type T = {
  [string]: number,
  ...,
}

type T = {
  // comment
  ...,
}

// Prettier 2.0.2
type T = {
  [string]: number,
  ...,
}

type T = {
  // comment
  ...,
}

// Prettier 2.0.3
type T = {
  [string]: number,
  ...
}

type T = {
  // comment
  ...
}

HTML

Fix printing of ignored empty inline elements (#7867 by @fisker)

<!-- Input-->
<!--prettier-ignore--><span></span>
<!--prettier-ignore--><span>_</span>

<!-- Prettier 2.0.2 (first output) -->
<!--prettier-ignore--><span
></span>
<!--prettier-ignore--><span>_</span>

<!-- Prettier 2.0.2 (second output) -->
<!--prettier-ignore--><span

></span>
<!--prettier-ignore--><span>_</span>

<!-- Prettier 2.0.3 -->
<!--prettier-ignore--><span></span>
<!--prettier-ignore--><span>_</span>

Format script and style inside tags with a colon in the name (#7916 by @fisker)

<!-- Input -->
<with:colon>
<script>function foo(){      return 1}</script>
<style>a         {color:         #f00}</style>
</with:colon>

<!-- Prettier 2.0.2 -->
<with:colon>
  <script>
    function foo(){ return 1}
  </script>
  <style>
    a {color: #f00}
  </style>
</with:colon>

<!-- Prettier 2.0.3 -->
<with:colon>
  <script>
    function foo() {
      return 1;
    }
  </script>
  <style>
    a {
      color: #f00;
    }
  </style>
</with:colon>

Other changes

2.0.2

diff

2.0 regressions

JavaScript: Fix formatting of pseudo-elements and pseudo-classes in styled-components template literals (#7842 by @thorn0)

// Input
const Foo = styled.div`
  ${media.smallDown}::before {}
`;

// Prettier 2.0.0
const Foo = styled.div`
  ${media.smallDown}: : before{
  }
`;

// Prettier 2.0.2
const Foo = styled.div`
  ${media.smallDown}::before {
  }
`;

TypeScript: Avoid trailing commas on index signatures with only one parameter (#7836 by @bakkot)

TypeScript index signatures technically allow multiple parameters and trailing commas, but it's an error to have multiple parameters there, and Babel's TypeScript parser does not accept them. So Prettier now avoids putting a trailing comma there when you have only one parameter.

// Input
export type A = {
  a?: {
    [
      x: string
    ]: typeof SomeLongLongLongTypeName[keyof typeof SomeLongLongLongTypeName];
  } | null;
};

// Prettier 2.0.0
export type A = {
  a?: {
    [
      x: string,
    ]: typeof SomeLongLongLongTypeName[keyof typeof SomeLongLongLongTypeName];
  } | null;
};

// Prettier 2.0.2
export type A = {
  a?: {
    [
      x: string
    ]: typeof SomeLongLongLongTypeName[keyof typeof SomeLongLongLongTypeName];
  } | null;
};

Revert "markdown: fix redundant leading spaces in markdown list" (#7847)

See #7846

Other changes

TypeScript: Fix prettier-ignore in union types (#7798 by @thorn0)

// Input
export type a =
  // foo
  | foo1&foo2
  // prettier-ignore
  | bar1&bar2
  // baz
  | baz1&baz2;

// Prettier 2.0.0
export type a =
  // foo
  | foo1&foo2
    // prettier-ignore
  // prettier-ignore
  | (bar1 & bar2)
  // baz
  | (baz1 & baz2);

// Prettier 2.0.2
export type a =
  // foo
  | (foo1 & foo2)
  // prettier-ignore
  | bar1&bar2
  // baz
  | (baz1 & baz2);

2.0.1

diff

API: Fix build script to not corrupt import-fresh module (#7820 by @thorn0)

2.0.0

diff

πŸ”— Release Notes

1.19.1

diff

CLI

Fix --stdin regression in 1.19.0 (#6894 by @lydell)

// Prettier stable
$ echo "test" | prettier --stdin --parser babel
[error] regeneratorRuntime is not defined

// Prettier master
$ echo "test" | prettier --stdin --parser babel
test;

TypeScript

Fix formatting of union type as arrow function return type (#6896 by @thorn0)

// Input
export const getVehicleDescriptor = async (
  vehicleId: string,
): Promise<Collections.Parts.PrintedCircuitBoardAssembly['attributes'] | undefined> => {}

// Prettier stable
export const getVehicleDescriptor = async (
  vehicleId: string
): Promise<| Collections.Parts.PrintedCircuitBoardAssembly["attributes"]
| undefined> => {};

// Prettier master
export const getVehicleDescriptor = async (
  vehicleId: string
): Promise<
  Collections.Parts.PrintedCircuitBoardAssembly["attributes"] | undefined
> => {};

1.19.0

diff

πŸ”— Release Notes

1.18.2

diff

  • TypeScript: only add trailing commas in tuples for --trailing-comma=all (#6199 by @duailibe)

    In Prettier 1.18 we added trailing commas in tuples when --trailing-comma=all, but it was also adding for --trailing-comma=es5.

1.18.1

diff

  • TypeScript: Add trailing comma in tsx, only for arrow function (#6190 by @sosukesuzuki)

    Prettier inserts a trailing comma to single type parameter for arrow functions in tsx, since v 1.18. But, this feature inserts a trailing comma to type parameter for besides arrow functions too (e.g, function , interface). This change fix it.

    // Input
    interface Interface1<T> {
      one: "one";
    }
    function function1<T>() {
      return "one";
    }
    
    // Output (Prettier 1.18.0)
    interface Interface1<T,> {
      one: "one";
    }
    function function1<T,>() {
      return "one";
    }
    
    // Output (Prettier 1.18.1)
    interface Interface1<T> {
      one: "one";
    }
    function function1<T>() {
      return "one";
    }
  • Config: Match dotfiles in config overrides (#6194 by @duailibe)

    When using overrides in the config file, Prettier was not matching dotfiles (files that start with .). This was fixed in 1.18.1

1.18.0

diff

πŸ”— Release Notes

1.17.1

diff

  • Range: Fix ranged formatting not using the correct line width (#6050 by @mathieulj)

    // Input
    function f() {
      if (true) {
        call("this line is 79 chars", "long", "it should", "stay as single line");
      }
    }
    
    // Output (Prettier 1.17.0 run with --range-start 30 --range-end 110)
    function f() {
      if (true) {
        call(
          "this line is 79 chars",
          "long",
          "it should",
          "stay as single line"
        );
      }
    }
    
    // Output (Prettier 1.17.0 run without range)
    function f() {
      if (true) {
        call("this line is 79 chars", "long", "it should", "stay as single line");
      }
    }
    
    // Output (Prettier 1.17.1 with and without range)
    function f() {
      if (true) {
        call("this line is 79 chars", "long", "it should", "stay as single line");
      }
    }
  • JavaScript: Fix closure compiler typecasts ([#5947] by @jridgewell)

    If a closing parenthesis follows after a typecast in an inner expression, the typecast would wrap everything to the that following parenthesis.

    // Input
    test(/** @type {!Array} */(arrOrString).length);
    test(/** @type {!Array} */((arrOrString)).length + 1);
    
    // Output (Prettier 1.17.0)
    test(/** @type {!Array} */ (arrOrString.length));
    test(/** @type {!Array} */ (arrOrString.length + 1));
    
    // Output (Prettier 1.17.1)
    test(/** @type {!Array} */ (arrOrString).length);
    test(/** @type {!Array} */ (arrOrString).length + 1);
  • JavaScript: respect parenthesis around optional chaining before await (#6087 by @evilebottnawi)

    // Input
    async function myFunction() {
      var x = (await foo.bar.blah)?.hi;
    }
    
    // Output (Prettier 1.17.0)
    async function myFunction() {
      var x = await foo.bar.blah?.hi;
    }
    
    // Output (Prettier 1.17.1)
    async function myFunction() {
      var x = (await foo.bar.blah)?.hi;
    }
  • Handlebars: Fix {{else}}{{#if}} into {{else if}} merging (#6080 by @dcyriller)

    // Input
    {{#if a}}
      a
    {{else}}
      {{#if c}}
        c
      {{/if}}
      e
    {{/if}}
    
    // Output (Prettier 1.17.0)
    {{#if a}}
      a
    {{else if c}}
      c
    e
    {{/if}}
    
    // Output (Prettier 1.17.1)
    Code Sample
    {{#if a}}
      a
    {{else}}
      {{#if c}}
        c
      {{/if}}
      e
    {{/if}}
    
  • JavaScript: Improved multiline closure compiler typecast comment detection (#6070 by @yangsu)

    Previously, multiline closure compiler typecast comments with lines that start with * weren't flagged correctly and the subsequent parenthesis were stripped. Prettier 1.17.1 fixes this issue.

    // Input
    const style =/**
     * @type {{
     *   width: number,
     * }}
    */({
      width,
    });
    
    // Output (Prettier 1.17.0)
    const style =/**
     * @type {{
     *   width: number,
     * }}
    */ {
      width,
    };
    
    // Output (Prettier 1.17.1)
    const style =/**
     * @type {{
     *   width: number,
     * }}
    */({
      width,
    });

1.17.0

diff

πŸ”— Release Notes

1.16.4

diff

  • API: Fix prettier.getSupportInfo() reporting babel parser for older versions of Prettier. (#5826 by @azz)

    In version 1.16.0 of Prettier, the babylon parser was renamed to babel. Unfortunately this lead to a minor breaking change: prettier.getSupportInfo('1.15.0') would report that it supported babel, not babylon, which breaks text-editor integrations. This has now been fixed.

1.16.3

diff

  • TypeScript: Revert "Update typescript-estree to new package name" (#5818 by @ikatyang)

    There's an internal change introduced in Prettier 1.16.2, which updated typescript-estree to its new package name, but unfortunately it broke the output so we reverted it as a temporary workaround for now.

    // Input
    export default {
      load<K, T>(k: K, t: T) {
        return {k, t};
      }
    }
    
    // Output (Prettier 1.16.2)
    export default {
      load(k: K, t: T) {
        return { k, t };
      }
    };
    
    // Output (Prettier 1.16.3)
    export default {
      load<K, T>(k: K, t: T) {
        return { k, t };
      }
    };

1.16.2

diff

  • CLI: Fix CI detection to avoid unwanted TTY behavior (#5804 by @kachkaev)

    In Prettier 1.16.0 and 1.16.1, --list-different and --check logged every file in some CI environments, instead of just unformatted files. This unwanted behavior is now fixed.

  • HTML: Do not format non-normal whitespace as normal whitespace (#5797 by @ikatyang)

    Previously, only non-breaking whitespaces (U+00A0) are marked as non-normal whitespace, which means other non-normal whitespaces such as non-breaking narrow whitespaces (U+202F) could be formatted as normal whitespaces, which breaks the output. We now follow the spec to exclude all non-ASCII whitespace from whitespace normalization.

    (Β· represents a non-breaking narrow whitespace)

    <!-- Input -->
    PrixΒ·:Β·32·€
    
    <!-- Output (Prettier 1.16.1) -->
    Prix : 32 €
    
    <!-- Output (Prettier 1.16.2) -->
    PrixΒ·:Β·32·€
  • JavaScript: Fix record type cast comment detection (#5793 by @yangsu)

    Previously, type cast comments with record types were ignored and prettier stripped the subsequent parens. Prettier 1.16.2 handles these cases correctly.

    // Input
    const v = /** @type {{key: number}} */ (value);
    
    // Output (Prettier 1.16.1)
    const v = /** @type {{key: number}} */ value;
    
    // Output (Prettier 1.16.2)
    const v = /** @type {{key: number}} */ (value);

1.16.1

diff

  • JavaScript: Do not format functions with arguments as react hooks (#5778 by @SimenB)

    The formatting added in Prettier 1.16 would format any function receiving an arrow function and an array literal to match React Hook's documentation. Prettier will now format this the same as before that change if the arrow function receives any arguments.

    // Input
    ["red", "white", "blue", "black", "hotpink", "rebeccapurple"].reduce(
      (allColors, color) => {
        return allColors.concat(color);
      },
      []
    );
    
    // Output (Prettier 1.16.0)
    ["red", "white", "blue", "black", "hotpink", "rebeccapurple"].reduce((
      allColors,
      color
    ) => {
      return allColors.concat(color);
    }, []);
    
    // Output (Prettier 1.16.1)
    ["red", "white", "blue", "black", "hotpink", "rebeccapurple"].reduce(
      (allColors, color) => {
        return allColors.concat(color);
      },
      []
    );
  • JavaScript: Add necessary parentheses for decorators (#5785 by @ikatyang)

    Parentheses for decorators with nested call expressions are optional for legacy decorators but they're required for decorators in the current proposal.

    // Input
    class X {
      @(computed().volatile())
      prop
    }
    
    // Output (Prettier 1.16.0)
    class X {
      @computed().volatile()
      prop
    }
    
    // Output (Prettier 1.16.1)
    class X {
      @(computed().volatile())
      prop
    }
  • TypeScript: Stable parentheses for function type in the return type of arrow function (#5790 by @ikatyang)

    There's a regression introduced in 1.16 that parentheses for function type in the return type of arrow function were kept adding/removing. Their parentheses are always printed now.

    // Input
    const foo = (): (() => void) => (): void => null;
    const bar = (): () => void => (): void => null;
    
    // First Output (Prettier 1.16.0)
    const foo = (): () => void => (): void => null;
    const bar = (): (() => void) => (): void => null;
    
    // Second Output (Prettier 1.16.0)
    const foo = (): (() => void) => (): void => null;
    const bar = (): () => void => (): void => null;
    
    // Output (Prettier 1.16.1)
    const foo = (): (() => void) => (): void => null;
    const bar = (): (() => void) => (): void => null;
  • MDX: Correctly recognize inline JSX (#5783 by @ikatyang)

    Previously, some inline JSXs are wrongly recognized as block HTML/JSX, which causes unexpected behaviors. This issue is now fixed.

    <!-- Input -->
    _foo <InlineJSX /> bar_
    
    <!-- Output (Prettier 1.16.0) -->
    _foo
    
    <InlineJSX /> bar_
    
    <!-- Output (Prettier 1.16.1) -->
    _foo <InlineJSX /> bar_

1.16.0

diff

πŸ”— Release Notes

1.15.3

diff

  • JavaScript: support htm (#5565)
  • JavaScript: support logical assignment operator (#5489)
  • JavaScript: do not add quotes for interpolation-only attributes in html templates (#5544)
  • JavaScript: add missing parenthesis for binary in optional member (#5543)
  • JavaScript: fix a parser regression (#5530)
  • JavaScript: improve union types with leading comments (#5575)
  • TypeScript: support BigInt (#5546, #5577)
  • TypeScript: inline method decorators should stay inlined (#5444)
  • TypeScript: do not change module into namespace and break/hug their body correctly (#5551)
  • TypeScript: do not add invalid semicolon for construct in interface with // prettier-ignore (#5469)
  • HTML: do not touch comments (#5525)
  • HTML: preserve bogus comments <! ... >/<? ... > (#5565)
  • HTML: support IE conditional start/end comment (#5470)
  • HTML: do not add extra indentation for js template in <script> (#5527)
  • HTML: leading spaces for the first interpolation in <textarea> are sensitive (#5468)
  • HTML: preserve content for element in <pre> correctly (#5473)
  • HTML: correct column for error code frame (#5553)
  • Angular: support interpolation in attributes (#5573)
  • Angular: do not print colon for then and else in *ngIf (#5542)
  • Angular/Vue: do not normalize tag/attribute names (#5526, #5549)
  • Vue: preserve custom block (#5458)
  • Vue: remove unnecessary semicolon and preserve necessary semicolon for single expression in event bindings (#5519)
  • Vue: group slot-scope correctly (#5563)
  • Markdown: do not trim content in inline-math (#5485)
  • Markdown: add more category to CJK regex (#5480)
  • SCSS: update parser for performance improvements (#5481)
  • YAML: preserve the first document head end marker --- (#5502)
  • API: resolve ignored field correctly in .getFileInfo() with absolute filePath (#5570)
  • API/CLI: fix a bug that caches for .js config files did not respect .clearConfigCache() (#5558)
  • API/CLI: ignore unset in .editorconfig (#5550)
  • CLI: report status code 0 for --list-different + --write (#5512)
  • Standalone: fix a regression for browser compatibility (#5560)

1.15.2

diff

  • CLI: allow flag overriding (#5390)
  • JavaScript: do not apply test call formatting to arrow function without body (#5366)
  • JavaScript: do not duplicate comments in styled-components (#5416)
  • JavaScript: do not indent comments behind variable declarations (#5434)
  • JavaScript: inline property decorator should stay inline (#5364, #5423)
  • JavaScript: treat createSelector as function composition (#5430)
  • Flow: do not move flow comment for function argument to its body (#5435)
  • Flow: force-break interface body to be consistent with TypeScript interface (#5432)
  • Flow/TypeScript: remove extra indentation for extends (#5432)
  • TypeScript: distinguish module and namespace correctly (#5432)
  • HTML: handle CRLF correctly (#5393)
  • HTML: handle <pre> with interpolation (#5400)
  • HTML: preserve content for <template> with unknown lang (#5388)
  • HTML: preserve incomplete IE conditional comments (#5429)
  • HTML: preserve unterminated IE conditional comments (#5424)
  • HTML: treat capital element as custom element (#5395)
  • Angular: add missing parens for pipe in ternary (#5397)
  • Angular: correctly print unary expression with operator + (#5405)
  • Angular: correctly handle parens (#5387)
  • Angular/Vue: whitespaces between interpolation and text are sensitive (#5396)
  • Vue: do not add invalid semicolon for v-on attribute value (#5418)
  • SCSS: do not crash on grid value (#5394)
  • Markdown: handle CRLF correctly (#5414)
  • Markdown: identify CJK correctly (#5402)
  • MDX: treat JSX code block same as in Markdown (#5391)

1.15.1

diff

  • Markdown: do not keep increasing backslashes for dollar sign (#5358)

1.15.0

diff

πŸ”— Release Notes

1.14.3

diff

  • Chore: add missing LICENSE (#5114)

1.14.2

diff

  • YAML: fix the line ending issue on Windows (#4957)
  • TypeScript: better error message (#4947)

1.14.1

diff

  • JavaScript: add parens for unary in bind (#4950)
  • JavaScript: format angular jasmine it("should ...", fakeAsync(() => { ... correctly. (#4954)
  • JavaScript: Revert this/super blacklist for function composition heuristic (#4936)
  • JavaScript: no extra space on Flow interface method named static (#4910)
  • JavaScript: no extra line break in destructed assignment of ternary (#4932)
  • Flow: print ObjectTypeInternalSlot with both flow/babel parsers (#4869)
  • TypeScript: no invalid output for ImportType in TypeReference (#4939)
  • YAML: do not throw on duplicate merge key (#4931)
  • YAML: no duplicate comments in mappingValue (#4931)
  • YAML: print end comment in nested mapping correctly (#4918)
  • YAML: do not put singleline values on a separate line from the key (#4916)
  • YAML: prefer dash as document separator (#4921)
  • API: update support info for Flow (#4943)
  • CLI: ignore .git, .svn and .hg directories (#4906)
  • CLI: support TOML configuration files (#4877)

1.14.0

diff

πŸ”— Release Notes

1.13.7

diff

  • Remove calls to eval("require") in the distributed code (#4766)

1.13.6

diff

  • Upgrade Flow parser to 0.75.0 (#4649 and #4727)
  • Preserve type parameters of import-types in TypeScript (#4662)
  • Preserve parens for type casting for sub-item (#4648)

1.13.5

diff

  • Better handling of trailing spaces in Markdown (#4593)
  • Fix empty file error in JSON and GraphQL (#4553)
  • Preserve decorator on TypeScript interfaces (#4632)
  • Inline _ or $ in the root of a method chain (#4621)

1.13.4

diff

  • Fix a regression when printing graphql-in-js (#4616)

1.13.3

diff

  • Fix a regression when printing hasOwnProperty and other functions in Object's prototype (#4603)
  • Fix a regression in exit status when using --debug-check and --list-different (#4600)

1.13.2

diff

  • Republished 1.13.1 with missing README included this time

1.13.1

diff

  • Revert default parser change in API (still present in CLI)

1.13.0

diff

πŸ”— Release Notes

1.12.1

diff

  • Fix for tag being removed from CSS with embedded expressions (#4302)
  • Wrap awaits in unary expressions with parens (#4315)
  • Fix style regression on flow union types (#4325)

1.12.0

diff

πŸ”— Release Notes

1.11.1

diff

  • 1.11.0 was incorrectly shipped with the wrong version of the TypeScript parser, which broke conditional types. This release fixes it.
  • Fixed an issue relating to deprecated parsers (#4072)

1.11.0

diff

πŸ”— Release Notes

1.10.2

diff

  • Fixed an issue printing .vue files with self-closing tags. (#3705 by duailibe)

1.10.1

diff

  • Fixed an issue where the CLI fails to resolve a file.

1.10.0

diff

πŸ”— Release Notes

1.9.2

diff

  • Fixed trailing comma not being printed in function calls if the last arg was an arrow (#3428 by duailibe)
  • Ignore whitespace after the /** in docblocks (#3430 by duailibe)
  • Fixed a bug where get and set class properties arrows would print an unnecessary semicolon with --no-semi (#3434 by duailibe)
  • Fixed a bug for missing .editorconfig files (#3439 by josephfrazier)
  • Fix comments being moved in class methods and object properties with the babylon parser (#3441 by duailibe)
  • Better printing of member chains with a TSNonNullExpression (! character) (#3442 by duailibe)
  • Fix missing commas in object properties when a prettier-ignore comment is present (#3448 by duailibe)
  • Fix printing union types inside a function param type (#3446 by duailibe)
  • Fix closing parens on multi-line intersection/union type (#3436 by josephfrazier)
  • Don't break single argument destructuring arguments (for arrays and with simple default values) (#3443 by duailibe)

1.9.1

diff

  • Fixed a bug of comments with JSX fragments being duplicated in output (#3398 by duailibe)
  • Fixed a bug that Prettier would fail when using tabs (#3401 by ikatyang)
  • Fixed a regression that removed trailing commas when printing JS code blocks in Markdown (#3405 by azz)
  • Fixed a bug when using glob **/* which would try to format directories (#3411 by duailibe)
  • Fixed a bug when .editorconfig had max_line_length = "off" (#3412 by duailibe)

1.9.0

diff

πŸ”— Release Notes

1.8.2

diff

  • Markdown: Don't break on links (#3204 by ikatyang)
  • Markdown: Add --no-prose-wrap option (#3199 by ikatyang)
  • TypeScript: Parenthesis around TSAsExpression inside TSAbstractClassDeclaration (#3191 by duailibe)
  • JSON: Print JSON top comments as leading comments of root node (#3187 by duailibe)

1.8.1

diff

  • Force JSON to no trailing comma in multiparser (#3182 by azz)
  • Don't add trailing commas in JSXAttribute for arrow functions (#3181 by duailibe)
  • Markdown: Allow more cases that _-style emphasis is available (#3186 by ikatyang)
  • Markdown: Handle additional spaces before code (#3180 by ikatyang)
  • Markdown: Do not break on unbreakable place (#3177 by ikatyang)
  • Markdown: Do not break before special prefix (#3172 by ikatyang)

1.8.0

diff

πŸ”— Release Notes

1.7.4

diff

  • Force template literals to break after ` for styled-components (#2926 by duailibe)
  • Update cosmiconfig to v3.1.0 (#2952 by ikatyang)
  • Respect --stdin-filepath, regardless of config source (#2948 by azz)

1.7.3

diff

  • Fix cosmiconfig in the built version of Prettier (#2930 by lydell)
  • Fix: ignore and show warning for unknown option from config file (#2929 by ikatyang)
  • Don't use parens with optional chaining member expressions (#2921 by azz)

1.7.2

diff

  • Revert "Fix line break in test declarations with a single argument function declaration" (#2912)

1.7.1

diff

  • Enable cosmiconfig rcExtensions (#2749 by elektronik2k5)
  • Keep original empty lines in argument list (#2763 by jackyho112)
  • Upgrade prettier dependency to 1.7.0, fix lint (#2821 by josephfrazier)
  • Fix different precedence binary expression when inlining (#2827 by duailibe)
  • Bump Babylon (#2831 by existentialism)
  • Don't lowercase Less variables when parsed with SCSS parser (#2833 by lydell)
  • Don't lowercase &class in SCSS/Less selectors (#2834 by lydell)
  • Add support for ClassPrivateProperty (#2837 by existentialism)
  • Upgrade cosmiconfig to v3, remove hardcoded combinatorial problem (#2843 by azz)
  • Split Less and SCSS parsing into different parsers (#2844 by lydell)
  • feat: support detailed --help (#2847 by ikatyang)
  • Update cosmiconfig to 3.0.1 to avoid memory leak (#2848 by danez)
  • chore: add prettier-stylelint to the related projects (#2859 by hugomrdias)
  • Don't lowercase SCSS placeholder selectors (#2876 by lydell)
  • Fix line break in test declarations with 2nd argument as a function (#2877 by duailibe)
  • Use semicolons in Flow interface-like bodies (#2593) (#2888 by motiz88)
  • We do not need to have a reference to the toolbox-companion since we (#2892 by mitermayer)
  • fix(cli): validate options for every config-precedence (#2894 by ikatyang)
  • fix: do not print stack trace for invalid option (#2895 by ikatyang)
  • refactor: use custom error (#2896 by ikatyang)
  • fix(typescript): allow symbol type (#2899 by ikatyang)
  • Support fit(), xit(), it.only(), etc (#2900 by azz)
  • Fix editor styling on empty editors (#2904 by jakegavin)
  • Fix printing of comments between decorators and method names (#2906 by azz)

1.7.0

diff

πŸ”— Release Notes

1.6.1

diff

  • Fix CLI option parsing with no arguments (#2684)
  • Fix config file finding when using stdin (#2692)
  • Fix union type with type params regression (#2688)
  • Fix flow parenthesis regression (#2687)

1.6.0

diff

πŸ”— Release Notes

1.5.3

diff

  • Force trailingComma option to "none" when parser is JSON (#2335)

1.5.2

diff

  • Full printing support for GraphQL and various bug fixes
  • Fixes for range formatting for JSON and CSS (#2295, #2298)

1.5.1

diff

  • Go back to babylon beta 13 (#2289)
  • Inline import('x') to avoid having trailing comma (#2288)

1.5.0

diff

πŸ”— Release Notes

1.4.4

πŸ”— Fix postcss, I forgot to re-run the build script :(

1.4.3

diff

  • Fix support for node 4 (#1988)
  • Fix website on iOS Safari (#1970)

Formatting change:

  • Position JSX whitespace ({" "}) at the end of lines (#1964)

Lots of small fixes, mainly for TypeScript.

1.4.2

diff

  • fix(decorators): do not inline methods with decorators with babylon (#1934)
  • fix(typescript): print semi with inline interfaces/types (#1936)
  • fix(typescript): no semi after export default abstract class, fixes (#1937)
  • TypeScript: fix trailing comma in enum (#1938)

1.4.1

diff

  • Lots of fixes for TypeScript and regressions from 1.4.0. If you are using 1.4.0, you should migrate to 1.4.1 asap ;)

1.4.0

diff

πŸ”— Release Notes

1.3.1

diff

  • Respect template inline-ness (#1497)

1.3.0

diff

πŸ”— Release Notes

  • add printer branches for some TypeScript nodes (#1331)
  • Skip trailing commas with FlowShorthandWithOneArg (#1364)
  • add TSLastTypeNode and TSIndexedAccessType (#1370)
  • add TSConstructorType (#1367)
  • fix do-while break (#1373)
  • Fix missing trailing commas on flow generics (#1381)
  • Add example of using yarn test with arguments (#1383)
  • Have --debug-check also run ast verification (#1337)
  • Fix empty line in block with EmptyStatement (#1375)
  • parent decides how to print type annotations (#1391)
  • add TSTypeOperator (#1396)
  • fix TSTypeReference not printing typeArguments (#1392)
  • add TSMappedType and TSTypeParameter (#1393)
  • fix TSFunctionType failing on TypeParameters (#1394)
  • add TSIntersectionType (#1395)
  • fix typeParameters printing TSFunctionType w/o breaking flow (#1397)
  • Fix optional flow parenthesis (#1357)
  • [experimental] Add linting step in test pipeline (#1172)
  • fix VariableDeclarator not printing type parameters (#1415)
  • add TSMethodSignature (#1416)
  • Add TSParameterProperty, TSAbstractClassDeclaration and TSAbstractMethodDefinition (#1410)
  • Inline nullable in flow generics (#1426)
  • fixed method 'check' error 'format' of undefined (#1424)
  • feat(typescript): add declare modifier support for vars, classes and functions (#1436)
  • Allow flow declarations to break on StringLiteralTypeAnnotations (#1437)
  • Require '::a.b' to have a preceding ; in no-semi style (#1442)
  • Require '(a || b).c++' to have a preceding ; in no-semi style (#1443)
  • Upgrade flow parser to 0.45 (#1447)
  • Add supertype tests and add TSAbstractClassProperty (#1467)
  • Break class expression returned by arrow call (#1464)
  • update typescript snapshots to account for #1464 (#1470)
  • [WIP] add TSNamespaceExportDeclaration (#1459)
  • update yarn.lock (#1471)
  • [RFC] Do not indent calls with a single template literal argument (#873)
  • Proper indentation for template literals (#1385)
  • Add parenthesis for unusual nested ternaries (#1386)
  • Preserve inline comment as last argument (#1390)
  • Only add parenthesis on ternaries inside of arrow functions if doesn't break (#1450)
  • Fix windows line ending on template literals (#1439)
  • Add space around = for flow generics default arguments (#1476)
  • Don't break for unparenthesised single argument flow function (#1452)
  • Don't break on empty arrays and objects (#1440)
  • Do not break on [0] (#1441)
  • Reorder flow object props (#1451)
  • Break inline object first in function arguments (#1453)
  • Break inline object first in function arguments (#1453) (#1173)
  • Inline template literals as arrow body (#1485)

1.2.2

diff

  • Only break for conditionals (#1350)

1.2.1

diff

  • Fix duplicate comments in classes (#1349)

1.2.0

diff

πŸ”— Release Notes

  • match jsx files in pre-commit hook (#1276)
  • Fix isPreviousLineEmpty on Windows (#1263)
  • Add --dev option to suggested install cmd (#1289)
  • Write out change CLI changes synchronously. Fixes #1287. (#1292)
  • Remove emoji part from lint-staged's name (#1302)
  • omit 'doc' key from options object before passing it to format() (#1299)
  • Skip globbing filenames with node-glob when the filename is not a glob (#1307)
  • FIX: more documentation for jetbrains (#1265)
  • Fix template literal comments (#1296)
  • Double quotes for option values in Readme file (#1314)
  • Do not print the sub-tree when using prettier-ignore (#1286)
  • Bail when traversing === groups (#1294)
  • Avoid breaking arguments for last arg expansion (#1305)
  • Add typescript as a valid parser value (#1318)
  • Add JetBrains File Watcher docs (#1310)
  • Add prettier_d to Related Projects (#1328)
  • Add parentheses for assignment as body of arrow (#1326)
  • Add information about Vim's other autocmd events (#1333)
  • add printer branch for TSFirstTypeNode (#1332)
  • Optimize prettier --help for humans (#1340)
  • Update link to @vjeux's React London presentation (#1330)
  • Improve regex printing (#1341)
  • Fix arrow function parenthesis with comments in flow (#1339)
  • Break if () if conditional inside breaks (#1344)
  • Don't inline paren at right of arguments (#1345)

1.1.0

diff

  • Prettier 1.0 is the stabler release we've been waiting for (#1242)
  • fix small typo (#1255)
  • Fix : ReferenceError: err is not defined (#1254)
  • Document debugging strategies (#1253)
  • Do not inline member expressions as part of assignments (#1256)
  • Fix flow union params (#1251)
  • Use a whitelist instead of blacklist for member breaking (#1261)
  • Remove trailing whitespace (#1259)
  • Get rid of fixFaultyLocations code (#1252)
  • Fixing n.comments check in printer (#1239)
  • [WIP] no-semi comments (#1257)

1.0.1

  • change semi default

1.0.0

diff

πŸ”— Release Notes

0.22.0

diff

  • Run 0.21.0 (#876)
  • Fix paren removal on UnionTypeAnnotation (#878)
  • Fix typo (#891)
  • Ensure no parens for JSX inside of an ArrayExpression (#895)
  • Fix object expression in arrow function expression (#897)
  • Fix unprinted comments in destructuring (#898)
  • Fix bug with importing empty type (#904)
  • Fix broken export comment (#899)
  • Add CLI Example to Readme (#909)
  • Fix 0.5e0 (#911)
  • Fix binary expression instanceof in arrow function expression (#913)
  • Improve readme CLI usage example (#910)
  • Do not break long it/test calls when template literal (#893)
  • Update lint-staged docs to use husky for less config. (#923)
  • Fix files with comments only (#813)
  • Update README.md (#928)
  • Fix binary op as body in arrow expression (#921)
  • cleanup needsParens (#935)
  • [JSX] Break if opening element breaks (#942)
  • Parenthesize function expressions in expression position (#941)
  • update the README to add a pre-commit hook (#944)
  • Fix #951: properly parenthesize ** expressions (#952)
  • [WIP] TypeScript Parser (#915)
  • Do not break long describe calls (#953)
  • Recursively find leading comments inside ReturnStatements (#955)
  • Fix in inside of a for in a nested way (#954)
  • Make comments around empty parenthesis be inside (#957)
  • Stabilize comment after object label (#958)
  • Inline BinaryExpressions inside JSXExpression (#965)
  • Only allow same-line arrow-less body for explicit nodes (#966)

0.21.0

diff

  • [JSX] Break before and after jsx whitespace (#836)
  • re-run snapshot tests
  • Run prettier 0.20.0 (#835)
  • [JSX] Don't wrap JSX Elements in parentheses in {} (#845)
  • Fix comment after the last argument of a function (#856)
  • Fix travis build image
  • Do not break require calls (#841)
  • Stabilize import as comments (#855)
  • Fix jsx expression comment that break (#852)
  • Inline last arg function arguments (#847)
  • Keep parenthesis on export default function (#844)
  • Inline short expressions for boolean operators too (#826)
  • Introduce -l option (#854)
  • Add parenthesis around assignments (#862)
  • Do not put \n after label (#860)
  • Fix comment for call( // comment (#858)
  • Do not break long it calls (#842)
  • Fix flow union comments (#853)

0.20.0

diff

  • Fix extra parens for update expressions (#796)
  • Fix empty options (#803)
  • Eagerly evaluate ifBreak when processing template literals (fixes #795
  • Fix function declaration params comments (#802)
  • Update flow to 0.40 (#808)
  • Correct link for travis
  • Fix function call args (#809)
  • Properly support do (#811)
  • Do not put parenthesis around not named default export (#819)
  • Adds another preset to related projects (#820)
  • Fix trailing commas in docs (#825)
  • Put short body of arrow functions on the same line (#829)
  • Preserve new lines for comments after = (#830)
  • Fix indentation of a merged group (#828)
  • Migrate class comments to the beginning (#831)
  • Update list of related projects (#833)
  • Allow breaking for logical expressions in member chains (#827)

0.19.0

diff

  • docs(README): use yarn add for consistency (#734)
  • Make trailing-comma option support 2 different modes (#641)
  • Update README with valid trailingComma options
  • Fix await ternary parenthesis (#740)
  • Fix missing dangling comment in exports (#741)
  • Fix missing dangling comments in arrays (#744)
  • Remove extra parenthesis around await inside of unary expression (#745)
  • Fix missing dangling comments in for loop (#742)
  • Add note about trailingComma option in versions 0.18.0 and below
  • Add missing explanatory comment in ForStatement case (#748)
  • Fix leading & operators in flow types (#738)
  • Fix missing comments in assignment pattern (#704)
  • Correctly place trailing comments in conditionals (#754)
  • Use double quotes in script wildcards to support windows cmd.exe. (#761)
  • Upgrade to Jest 19 (#762)
  • Upgrade to Jest 19.0.1 (#779)
  • Remove extra parens around ternary arguments of a new call (#776)
  • Do not attach comments to EmptyStatements in try/catch (#763)
  • Bump babylon & add test for async func decl (#790)
  • Add this for Member factory whitelist and remove softline (#782)
  • Do not expand empty catch (#783)
  • Group [0] at the end of the previous chain instead of beginning of next one (#784)
  • Do not format template literals (#749)
  • Revert babylon bump (#792)
  • Do not put trailing commas for function declaration in es5 mode (#791)
  • [WIP] Fix comments in template literals (#643)
  • Introduce line-suffix-boundary (#750)
  • [RFC] Add parenthesis around && inside of || (#780)
  • Fix tests on node 4

0.18.0

diff

  • fix --debug-check
  • [JSX] Don't add newline following newline (#690)
  • [Docs] Use replaceState API when demo code changes (#710)
  • Do not inline new as last argument (#705)
  • Inline objects & arrays as right part of a boolean expression (#692)
  • [RFC] Remove parenthesis object special case (#689)
  • Ensure importKind is printed (#718)
  • [Docs]: update Readme to reference VS extension (#720)
  • docs: Add pre-commit hook with πŸš«πŸ’© lint-staged section to the README (#714)
  • [RFC] Preserve new lines between array elements (#707)
  • Do not put \n inside of empty object method bodies (#706)
  • Align boolean inside of arrow functions (#691)
  • Fix trailing new lines preservation (#724)
  • Unified Split

0.17.1

diff

  • Use readline api to manipulate process.stdout output. (#687)

0.17.0

diff

  • [JSX] Fix spurious newline (fixes #614) (#628)
  • Add --debug-check cli option (#627)
  • Remove last trailing line for directives-only files (#609)
  • Expand vim instructions
  • Fix formatting in readme
  • Update snapshots
  • Preserve empty line before last comment (#594)
  • test on current release of node.js (#595)
  • [JSX] jsx-whitespace breaks with parent (fixes #622) (#626)
  • Log filename with [update] or [ignore] flags during --write process. (#584)
  • Do not indent binary expressions inside of if (#604)
  • Put short elements at right of single binary expression on same line (#605)
  • Run prettier 0.16.0 on the codebase (#631)
  • Preserve blank lines inside of objects (#606)
  • fix typo in JetBrains External Tool config readme (#679)
  • Fix dangling comments for arrays (#665)
  • Print line-suffix in --debug-print-doc (#676)
  • Avoid unneeded parenthesis for colon with comments (#673)
  • Stabilize comments inside of if/then/else before { (#672)
  • Soft break the first member of a chain (#667)
  • Stabilize comments inside of ternaries (#666)
  • Fix trailing commas with a trailing comment (#664)
  • Fix Flow union type annotations indentation (#650)
  • Ensure that all comments are printed (#571)
  • Properly support member chains comments (#668)
  • [WIP] Fix Flow DeclareTypeAlias (#669)
  • Add option for putting > on the last line in jsx (#661)
  • Always put a hardline before dangling comment (#675)
  • Fix comments in return statement argument (#657)
  • [RFC] Introduce prettier-ignore-next (#671)

0.16.0

diff

  • Revert "Print \x and \u escapes in strings and regexes lowercase (#522)
  • Fix ternary indent bug (#577)
  • jsx parentheses fix (#580)
  • Run prettier on 0.15.0 (#558)
  • Add parenthesis around single argument arrow if comments (#573)
  • Use breakParent inside of last arrow expansion (#559)
  • Support dangling comments in ClassBody (#570)
  • Make all the member expressions but the last one part of the first group (#589)
  • Break long imports (#590)
  • Remove the concept of globalPrecedingNode (#561)
  • Remove test.js and put it back in the gitignore
  • Fix use strict as expression statement (#602)
  • Use arrow function when inputted that way for flow objects (#608)
  • Better support try/catch comments (#607)
  • Print CallExpression comments inside of memberChain (#600)
  • Do not attach comments to EmptyStatement (#599)
  • Fix files with only comments on the flow parser (#598)
  • Remove first line special case (#597)
  • Fix single indented JSX comment (#596)
  • Print dangling on ast on all the paths

0.15.0

diff

  • Fix syntax error in empty object with dangling comment (#533)
  • Fix closing call expression commented out (#530)
  • Update bracketSpacing comment to say it's about {} (#529)
  • Add 0.14.1 to CHANGELOG (#525)
  • Print \x and \u escapes in strings and regexes lowercase (#522)
  • Fix Jetbrains example screenshot url. (#534)
  • Preserve next line with trailing comment (#535)
  • Break nested calls (#517)
  • Update snapshot tests from conflicting PRs
  • Reimplement MemberExpression printing (#469)
  • Remove spurious test.js
  • Fix small typo on Jetbrains section (#552)
  • [JSX] Handle non-breaking space (#557)
  • Make comments between if & else to look good (#544)
  • Whitelist UnaryExpression for parentless objects (#545)
  • Make comments inside of MemberExpression look good (#556)

0.14.1

diff

  • Fix range for object newline detection (#520)
    • a bugfix for "Keep expanded objects expanded" (#495)

0.14.0

diff

  • Only write to files if the change (#511)
  • Remove extra group when printing object values (#502)
  • Add documentation for JetBrains products. (#509)
  • Don't print trailing commas for object destructuring and rest (#512)
  • Mention eslint-config-prettier (#516)
  • [RFC] Keep expanded objects expanded (#495)
  • Do not always put an empty lines after directives (#505)
  • Print numbers in a uniform way (#498)

0.13.0

diff

  • Simplify arrow functions that use blocks (#496)
  • Properly print comments for BinaryExpression (#494)
  • Preserve empty line after comment (#493)
  • [JSX] Handle each line of text separately (#455)
  • Proper support for dangling comments (#492)

0.12.0

diff

  • [WIP] Add rationale document (#372)
  • Proper parenthesis for yield and await in conditional (#436)
  • Don't print double newlines at EOF to stdout (#437)
  • Explain the --color option in a comment (#434)
  • Validate user-provided config with jest-validate (#301)
  • Propagate breaks upwards automatically, introduce breakParent (#440)
  • Fix typo in variable name (#441)
  • Refactor traversal (#442)
  • Do not put a newline on empty {} for functions (#447)
  • Better error message for assertDoc (#449)
  • Remove multilineGroup (#450)
  • Ability to break on : for objects (#314)
  • Update snapshots
  • [RFC] Do not put spacing inside of arrays with bracketSpacing (#446)
  • Fix integer CLI arguments (#452)
  • Move tests around (#454)
  • Update package.json, use ast-types 0.9.4 (#453)
  • Update lockfile
  • Support printing import("a") (#458)
  • Explain that you can pass options to the spec runner (#460)
  • Fix spurious whitespace (#463)
  • Preserve new lines after directives (#464)
  • Put decorators on the same line (#459)
  • docs: add related projects (#456)
  • Add break points for class declaration (#466)
  • Added parens around in operator in for loops πŸš€. (#468)
  • CLI improvements (#478)
  • [RFC] Hug Conditionals in JSX (#473)
  • Refactor comment algorithm and improve newline/spaces detection (#482)
  • Indent ternaries (#484)
  • Indent computed member (#471)
  • Maintain windows line ending (#472)
  • Don't break up JSXOpeningElement if it only has a single text (#488)
  • Add CallExpression to the last argument expansion whitelist (#470)
  • Mention eslint-plugin-prettier in Related Projects (#490)
  • Stop using conditionalGroup inside of UnionTypeAnnotation (#491)

0.11.0

diff

Now using minor versions instead of patch versions for the releases.

  • Swap quotes (#355)
  • Drop jsesc (#357)
  • Use a Symbol instead of the private dep (#359)
  • Add parens for default export FunctionExpressions (#345)
  • Fix export extension output (#361)
  • Exit with an error if an unknown CLI option is passed (#365)
  • Warn if using deprecated CLI options (#364)
  • s/jscodefmt/prettier/ (#370)
  • Fix CLI options (#369)
  • Fix some parens cases for UpdateExpressions (#381)
  • Output strings with the minimum amount of escaped quotes (#390)
  • Ignore EmptyStatement inside of switch case (#391)
  • Support multiple standalones in import (#389)
  • Fix missing semi-colon in for loop and var body (#388)
  • Fix empty labels (#383)
  • Fix forced trailing comma (#382)
  • Empty switch should not have an empty line (#384)
  • add formatAST() for formatting ASTs directly (#393)
  • Fix class extends parenthesis (#396)
  • Fix class inside of binary expression missing parenthesis (#397)
  • Fix parenthesis in object as left-hand-side of template (#398)
  • Remove unneeded parens for FunctionExpression inside LogicalExpression (#399)
  • Remove trailing comma for array destructuring with rest (#400)
  • Fix +++x (#401)
  • Also do the class extend parenthesis for class expressions (#403)
  • Fix various parenthesis issues on the left side of template (#404)
  • Fix in inside of the first group of a for (#406)
  • Add parenthesis for arrow function inside of ternary (#408)
  • Add parenthesis around class expression when left side of call expression (#409)
  • Ensure computed method names don't lose quotes (#419)
  • Add parenthesis for yield inside of a conditional (#418)
  • Add parenthesis around assignment for arrow function body (#422)
  • Add parenthesis around export default assignments (#423)
  • Add parenthesis for class expression on left of member expression (#421)
  • Fix missing parens around object in MemberExpression (#424)
  • Re-run snapshot tests
  • Workaround flow bug around trailing comma (#427)
  • Add parenthesis when class expressions are left of a ternary (#428)
  • Revert "Workaround flow bug around trailing comma" (#429)
  • Update commands.md (#430)
  • Improve vim integration section (#416)
  • Add glob support to the CLI (#363)
  • Use babel-code-frame for syntax errors (#367)
  • Update yarn.lock

0.0.10

diff

  • Add description to package.json (#320)
  • Fix crash for single rest on class declaration (#315)
  • Add canonical link to Prettier SublimeText package. (#318)
  • Properly escape JSXText (#329)
  • Hug objects and arrays inside of JSXExpressionContainer (#213)
  • Add quotes around unicode keys in flow parser (#328)
  • Add tests for comments (#330)
  • Print dangling comments in blocks (#331)
  • Remove Printer module in favor of single function (#333)
  • Split pp.js into doc-{printer,builders,utils}.js (#334)
  • Fix node 4 (#336)
  • Remove unused functions from recast (#337)
  • Kill fromString (#335)
  • Extract parser.js (#338)
  • Normalize exports (#339)
  • Refactor index.js (#340)
  • Add semicolon to more default exports (#343)
  • Introduce --parser/parser option and deprecate --flow-parser/useFlowParser (#342)
  • Remove parens around AwaitExpression in ternary (#346)
  • Indent while test the same way as if test (#352)
  • Add debugging support for doc IR (#347)

0.0.9

diff

  • Workaround flow bug parsing astral unicode characters (#277)
  • Allow specifying the major mode that defun-before-save will use. (#276
  • Fix space missing before , on export with bracket spacing off (#278)
  • Fix space missing before , on import with bracket spacing off (#279)
  • Add newline after shebang if necessary. (#215)
  • Remove +1 from newline detection (#261)
  • Fix path when printing member chains so parens work properly (fixes #243
  • Ensure parens on NewExpression with function callee (#282)
  • Fix missing semi when default exporting CallExpression (#287)
  • Workaround flow parser bug with spread in arrays (#285)
  • Update flow-parser to 0.38 (#290)
  • Allow customizing args sent to prettier-command (#289)
  • Do not output trailing commas with rest arguments (#283)
  • Use exact versions in package.json (#291)
  • Use js native String.repeat() (#293)
  • Handle additional export default parens cases (#298)
  • Fix parens around anonymous functions (#297)
  • Introduce second argument to ifBreak (#302)
  • Fix bracketSpacing typo in tests (#299)
  • Remove unused variable (#304)
  • Fix trailing whitespace (#300)
  • add version flag (#294)
  • Add --run-in-band to travis (#306)
  • [JSX] Split elements on newlines and preserve whitespace (w/@yamafaktory) (#234)
  • Print binary and logical expressions in a nicer format (#262)

0.0.8

diff

  • Fix await parenthesis (#185)
  • Add note about Sublime Test github issue in readme
  • Remove legacy Recast code and simplify API. (#191)
  • Don't break to new line if logical/loop statements are without brackets. (#194)
  • Fix parenthesis for UpdateExpression (#198)
  • Fix directives printing for empty functions (#199)
  • Fix key quotes omission for flow parser (#203)
  • Fix comma when an arrow function with no arguments breaks (#210)
  • Last argument expansion works for arrow functions that return JSX (#211)
  • Remove faulty location check on template literals that throws in Nuclide (#218)
  • Add flow parser experimental options (#221)
  • Fix empty exports (#225)
  • Fix cases of missing parens with NewExpression (#230)
  • Fix issue with ArrowFunctionExpression parens (#236)
  • Add npm version badge (#240)
  • Consolidate badges in readme
  • Fix parens issue with nested UnaryExpressions (#237)
  • Escape strings using jsesc (#229)
  • Add newline for empty blocks {} (#205)
  • Fix empty export with from clause (#248)
  • Fix missing parenthesis for typeof and arrow functions (#249)
  • Fix FunctionExpression parens issues (#250)
  • Fix last element of an array being null (#232)
  • Make sure empty for loops generate valid code (#224)
  • Fix parens for functions inside TaggedTemplateExpression (#259)
  • Preserve the way numbers were written (#257)

0.0.7

diff

  • Update live editor to 0.0.6
  • Adds various prettier-browser changes (#175)
  • Fix [(0)] (#179)
  • Do not advance for forward skipSpaces (#176)
  • Fix windows line-endings (#177)
  • add license to package.json (#178)
  • Fix exponent in babylon (#181)
  • Make declare type consistent between babylon and flow (#183)
  • Fix DeclareInterface (#182)
  • Change test to workaround babylon bug (#184)

0.0.6

diff

  • Format property names consistently
  • remove node 0.10 from travis config, add travis badge to readme
  • Update snapshots
  • chore: link prettier package to its github project
  • add gitter badge to readme
  • add instructions for Visual Studio plugin
  • Do not unquote string properties
  • Add prettier-browser
  • v0.0.5 -- Accidentally didn't push this commit out before others landed; 0.0.5 is actually based on commit faed09c
  • update yarn.lock
  • remove recast (not used)
  • Always use double quotes for JSX and properly escape
  • remove unused recast ref
  • Fix typo in README.
  • Support type annotation for rest argument on babylon parser
  • Use setq instead of infc and decf
  • Add title and encoding to the REPL
  • Fix old name reference in tests_config
  • Minimize string escapes
  • Support method generics on babylon parser
  • Break long exports into multiple lines.
  • Use group instead of conditionalGroup
  • Fix misprinting of computed properties in method chains. (#157)
  • treat shebang outside of parsing (#137)
  • Break multiline imports (#167)
  • Do not put spaces on empty for loop (#169)
  • Add trailing comma support for multiline exports (#168)
  • Update run_spec to support options
  • Add tests for bracketSpacing option
  • Add tests for quotes option
  • Add tests for tabWidth option
  • Add tests for trailingComma option
  • Fix for Node 4
  • Add test for shebang and move to index.js (#170)
  • Numeric literal callees should keep parens (#141)
  • Remove leftover arrowParensAlways option (#171)
  • Wrap Stateless JSX Arrow Functions and Assignment in Parens (fixes part of #73)
  • Break JSXOpeningElement between attributes (fixes #15)
  • JSX maintains spaces that matter (fixes #30 and thus part of #73)
  • Multiline JSX opening tag breaks children out too (for #73)
  • Add regression tests for long JSX Expression contents
  • include index.js in format:all script (#132)
  • Wrap ForStatement in a block for const decls (#172)
  • Reprint all the files!