Use the default (80 characters) width

Author: fatfisz

.prettierrc

@@ -1,5 +1,4 @@
 {
-  "printWidth": 100,
   "singleQuote": true,
   "trailingComma": "all"
 }

src/TemplateTag/TemplateTag.js

@@ -73,7 +73,10 @@ export default class TemplateTag {
    * @return {String}                 - the result of joining this iteration's processed substitution with the result
    */
   processSubstitutions(substitutions, resultSoFar, remainingPart) {
-    const substitution = this.transformSubstitution(substitutions.shift(), resultSoFar);
+    const substitution = this.transformSubstitution(
+      substitutions.shift(),
+      resultSoFar,
+    );
     return resultSoFar + substitution + remainingPart;
   }
 
@@ -84,7 +87,8 @@ export default class TemplateTag {
    * @return {String}     - The final results of processing each transformer
    */
   transformString(str) {
-    const cb = (res, transform) => (transform.onString ? transform.onString(res) : res);
+    const cb = (res, transform) =>
+      transform.onString ? transform.onString(res) : res;
     return this.transformers.reduce(cb, str);
   }
 
@@ -97,7 +101,9 @@ export default class TemplateTag {
    */
   transformSubstitution(substitution, resultSoFar) {
     const cb = (res, transform) =>
-      transform.onSubstitution ? transform.onSubstitution(res, resultSoFar) : res;
+      transform.onSubstitution
+        ? transform.onSubstitution(res, resultSoFar)
+        : res;
     return this.transformers.reduce(cb, substitution);
   }
 
@@ -108,7 +114,8 @@ export default class TemplateTag {
    * @return {String}           - The final results of processing each transformer
    */
   transformEndResult(endResult) {
-    const cb = (res, transform) => (transform.onEndResult ? transform.onEndResult(res) : res);
+    const cb = (res, transform) =>
+      transform.onEndResult ? transform.onEndResult(res) : res;
     return this.transformers.reduce(cb, endResult);
   }
 }

src/html/html.test.js

@@ -32,7 +32,10 @@ test('converts strings containing newlines into proper indented output', async t
 
 test('does not introduce excess newlines', async t => {
   const newlines = '<li>one</li>\n<li>two</li>';
-  const expected = await readFromFixture(__dirname, 'newline-conversion-after-newline');
+  const expected = await readFromFixture(
+    __dirname,
+    'newline-conversion-after-newline',
+  );
   const actual = html`
     <h1>${val}${nil}</h1>
     <ul>

src/index.test.js

@@ -23,6 +23,9 @@ test('common-tags exports all the right modules as props', async t => {
   const modules = t.context.modules;
   t.plan(modules.length);
   modules.forEach(module => {
-    t.true(require('./index')[module] != null, `${module} is not exported properly`);
+    t.true(
+      require('./index')[module] != null,
+      `${module} is not exported properly`,
+    );
   });
 });

src/inlineArrayTransformer/inlineArrayTransformer.test.js

@@ -9,22 +9,35 @@ test('only operates on arrays', t => {
 
 test('includes an array as a comma-separated list', t => {
   const tag = new TemplateTag(inlineArrayTransformer({ separator: ',' }));
-  t.is(tag`I like ${['apple', 'banana', 'kiwi']}`, 'I like apple, banana, kiwi');
+  t.is(
+    tag`I like ${['apple', 'banana', 'kiwi']}`,
+    'I like apple, banana, kiwi',
+  );
 });
 
 test('replaces last separator with a conjunction', t => {
-  const tag = new TemplateTag(inlineArrayTransformer({ separator: ',', conjunction: 'and' }));
-  t.is(tag`I like ${['apple', 'banana', 'kiwi']}`, 'I like apple, banana and kiwi');
+  const tag = new TemplateTag(
+    inlineArrayTransformer({ separator: ',', conjunction: 'and' }),
+  );
+  t.is(
+    tag`I like ${['apple', 'banana', 'kiwi']}`,
+    'I like apple, banana and kiwi',
+  );
 });
 
 test('does not use a conjunction if there is only one item in an array', t => {
-  const tag = new TemplateTag(inlineArrayTransformer({ separator: ',', conjunction: 'and' }));
+  const tag = new TemplateTag(
+    inlineArrayTransformer({ separator: ',', conjunction: 'and' }),
+  );
   t.is(tag`I like ${['apple']}`, 'I like apple');
 });
 
 test('does not require preceded whitespace', t => {
   const tag = new TemplateTag(inlineArrayTransformer({ separator: ',' }));
-  t.is(tag`My friends are (${['bob', 'sally', 'jim']})`, 'My friends are (bob, sally, jim)');
+  t.is(
+    tag`My friends are (${['bob', 'sally', 'jim']})`,
+    'My friends are (bob, sally, jim)',
+  );
 });
 
 test('supports serial/oxford separators', t => {

src/oneLineCommaListsAnd/oneLineCommaListsAnd.test.js

@@ -16,7 +16,10 @@ test('includes arrays as comma-separated list on one line with "and"', async t =
 
 test('only returns the first item of a single element array', async t => {
   const fruits = ['apple'];
-  const expected = await readFromFixture(__dirname, 'oneLineCommaListsAndSingleItem');
+  const expected = await readFromFixture(
+    __dirname,
+    'oneLineCommaListsAndSingleItem',
+  );
   const actual = oneLineCommaListsAnd`
     Doge <3's these fruits: ${fruits}
     they are ${val}

src/oneLineCommaListsOr/oneLineCommaListsOr.test.js

@@ -16,7 +16,10 @@ test('includes arrays as comma-separated list on one line with "or"', async t =>
 
 test('only returns the first item of a single element array', async t => {
   const fruits = ['apple'];
-  const expected = await readFromFixture(__dirname, 'oneLineCommaListsOrSingleItem');
+  const expected = await readFromFixture(
+    __dirname,
+    'oneLineCommaListsOrSingleItem',
+  );
   const actual = oneLineCommaListsOr`
     Doge <3's these fruits: ${fruits}
     they are ${val}

src/removeNonPrintingValuesTransformer/removeNonPrintingValuesTransformer.js

@@ -1,4 +1,5 @@
-const isValidValue = x => x != null && !Number.isNaN(x) && typeof x !== 'boolean';
+const isValidValue = x =>
+  x != null && !Number.isNaN(x) && typeof x !== 'boolean';
 
 const removeNonPrintingValuesTransformer = () => ({
   onSubstitution(substitution) {

src/removeNonPrintingValuesTransformer/removeNonPrintingValuesTransformer.test.js

@@ -23,7 +23,10 @@ test('removes NaN', t => {
 });
 
 test('removes non-printing array values', t => {
-  const remove = new TemplateTag(removeNonPrintingValuesTransformer, inlineArrayTransformer);
+  const remove = new TemplateTag(
+    removeNonPrintingValuesTransformer,
+    inlineArrayTransformer,
+  );
   const val = ['foo', undefined, 'bar', null];
   t.is(remove`a ${val} z`, 'a foo bar z');
 });

src/replaceResultTransformer/replaceResultTransformer.js

@@ -7,7 +7,9 @@
 const replaceResultTransformer = (replaceWhat, replaceWith) => ({
   onEndResult(endResult) {
     if (replaceWhat == null || replaceWith == null) {
-      throw new Error('replaceResultTransformer requires at least 2 arguments.');
+      throw new Error(
+        'replaceResultTransformer requires at least 2 arguments.',
+      );
     }
     return endResult.replace(replaceWhat, replaceWith);
   },

src/replaceResultTransformer/replaceResultTransformer.test.js

@@ -4,7 +4,10 @@ import replaceResultTransformer from './replaceResultTransformer';
 import trimResultTransformer from '../trimResultTransformer';
 
 test('replaces sequential whitespace with a single space', t => {
-  const oneLine = new TemplateTag(replaceResultTransformer(/(?:\s+)/g, ' '), trimResultTransformer);
+  const oneLine = new TemplateTag(
+    replaceResultTransformer(/(?:\s+)/g, ' '),
+    trimResultTransformer,
+  );
   const expected = 'foo bar baz';
   const actual = oneLine`
     foo

src/replaceStringTransformer/replaceStringTransformer.js

@@ -1,7 +1,9 @@
 const replaceStringTransformer = (replaceWhat, replaceWith) => ({
   onString(str) {
     if (replaceWhat == null || replaceWith == null) {
-      throw new Error('replaceStringTransformer requires at least 2 arguments.');
+      throw new Error(
+        'replaceStringTransformer requires at least 2 arguments.',
+      );
     }
 
     return str.replace(replaceWhat, replaceWith);

src/replaceStringTransformer/replaceStringTransformer.test.js

@@ -7,7 +7,10 @@ test('only operates on strings', t => {
     replaceStringTransformer(/</g, '&lt;'),
     replaceStringTransformer(/>/g, '&gt;'),
   );
-  t.is(tag`<h1>foo${'<bar></bar>'}</h1>`, '&lt;h1&gt;foo<bar></bar>&lt;/h1&gt;');
+  t.is(
+    tag`<h1>foo${'<bar></bar>'}</h1>`,
+    '&lt;h1&gt;foo<bar></bar>&lt;/h1&gt;',
+  );
 });
 
 test('throws error if no arguments are supplied when used', t => {

src/replaceSubstitutionTransformer/replaceSubstitutionTransformer.js

@@ -1,7 +1,9 @@
 const replaceSubstitutionTransformer = (replaceWhat, replaceWith) => ({
   onSubstitution(substitution, resultSoFar) {
     if (replaceWhat == null || replaceWith == null) {
-      throw new Error('replaceSubstitutionTransformer requires at least 2 arguments.');
+      throw new Error(
+        'replaceSubstitutionTransformer requires at least 2 arguments.',
+      );
     }
 
     // Do not touch if null or undefined

src/replaceSubstitutionTransformer/replaceSubstitutionTransformer.test.js

@@ -7,7 +7,10 @@ test('only operates on substitutions', t => {
     replaceSubstitutionTransformer(/</g, '&lt;'),
     replaceSubstitutionTransformer(/>/g, '&gt;'),
   );
-  t.is(tag`<h1>foo${'<bar></bar>'}</h1>`, '<h1>foo&lt;bar&gt;&lt;/bar&gt;</h1>');
+  t.is(
+    tag`<h1>foo${'<bar></bar>'}</h1>`,
+    '<h1>foo&lt;bar&gt;&lt;/bar&gt;</h1>',
+  );
 });
 
 test('does not touch undefined and null substitutions', t => {

src/splitStringTransformer/splitStringTransformer.test.js

@@ -4,7 +4,10 @@ import inlineArrayTransformer from '../inlineArrayTransformer';
 import splitStringTransformer from './splitStringTransformer';
 
 test('splits a string substitution into an array by the specified character', t => {
-  const tag = new TemplateTag(splitStringTransformer('\n'), inlineArrayTransformer);
+  const tag = new TemplateTag(
+    splitStringTransformer('\n'),
+    inlineArrayTransformer,
+  );
   t.is(tag`foo ${'bar\nbaz'}`, 'foo bar baz');
 });
 

src/stripIndent/stripIndent.js

@@ -2,6 +2,9 @@ import TemplateTag from '../TemplateTag';
 import stripIndentTransformer from '../stripIndentTransformer';
 import trimResultTransformer from '../trimResultTransformer';
 
-const stripIndent = new TemplateTag(stripIndentTransformer, trimResultTransformer);
+const stripIndent = new TemplateTag(
+  stripIndentTransformer,
+  trimResultTransformer,
+);
 
 export default stripIndent;

src/stripIndentTransformer/stripIndentTransformer.test.js

@@ -5,7 +5,10 @@ import trimResultTransformer from '../trimResultTransformer';
 import { readFromFixture } from '../utils';
 
 test('default behaviour removes the leading indent, but preserves the rest', async t => {
-  const stripIndent = new TemplateTag(stripIndentTransformer, trimResultTransformer);
+  const stripIndent = new TemplateTag(
+    stripIndentTransformer,
+    trimResultTransformer,
+  );
   const expected = await readFromFixture(__dirname, 'stripIndent');
   const actual = stripIndent`
     foo bar baz
@@ -17,14 +20,20 @@ test('default behaviour removes the leading indent, but preserves the rest', asy
 });
 
 test('type "initial" does not remove indents if there is no need to do so', t => {
-  const stripIndent = new TemplateTag(stripIndentTransformer, trimResultTransformer);
+  const stripIndent = new TemplateTag(
+    stripIndentTransformer,
+    trimResultTransformer,
+  );
   t.is(stripIndent``, '');
   t.is(stripIndent`foo`, 'foo');
   t.is(stripIndent`foo\nbar`, 'foo\nbar');
 });
 
 test('removes all indents if type is "all"', async t => {
-  const stripIndents = new TemplateTag(stripIndentTransformer('all'), trimResultTransformer);
+  const stripIndents = new TemplateTag(
+    stripIndentTransformer('all'),
+    trimResultTransformer,
+  );
   const expected = await readFromFixture(__dirname, 'stripIndents');
   const actual = stripIndents`
     foo bar baz

src/stripIndents/stripIndents.js

@@ -2,6 +2,9 @@ import TemplateTag from '../TemplateTag';
 import stripIndentTransformer from '../stripIndentTransformer';
 import trimResultTransformer from '../trimResultTransformer';
 
-const stripIndents = new TemplateTag(stripIndentTransformer('all'), trimResultTransformer);
+const stripIndents = new TemplateTag(
+  stripIndentTransformer('all'),
+  trimResultTransformer,
+);
 
 export default stripIndents;

src/trimResultTransformer/trimResultTransformer.test.js

@@ -34,7 +34,10 @@ test('throws an error if invalid side supplied', t => {
 });
 
 test('can be used sequentially', t => {
-  const trimStart = new TemplateTag(stripIndentTransformer, trimResultTransformer('start'));
+  const trimStart = new TemplateTag(
+    stripIndentTransformer,
+    trimResultTransformer('start'),
+  );
   t.is(trimStart`  foo  `, 'foo  ');
   t.is(trimStart`  bar  `, 'bar  ');
 });

src/utils/index.test.js

@@ -23,6 +23,9 @@ test('utils exports all the right modules as props', async t => {
   const modules = t.context.modules;
   t.plan(modules.length);
   modules.forEach(module => {
-    t.true(require('./index')[module] != null, `${module} is not exported properly`);
+    t.true(
+      require('./index')[module] != null,
+      `${module} is not exported properly`,
+    );
   });
 });