chore(deps): bump prettier from 1.18.2 to 1.19.1 (#454)

Author: dependabot-preview[bot]

package.json

@@ -41,7 +41,7 @@
     "jest": "^24.7.1",
     "lerna": "3.18.3",
     "lint-staged": "^9.0.0",
-    "prettier": "1.18.2",
+    "prettier": "1.19.1",
     "typescript": "~3.4.0",
     "yarn": "1.19.1"
   },
@@ -58,7 +58,7 @@
     }
   },
   "lint-staged": {
-    "packages/**/*.{ts,md,json}": [
+    "packages/**/*.{ts,js,md,json}": [
       "prettier --write",
       "git add"
     ]

packages/add-glacier-checksum-headers-browser/karma.conf.js

@@ -1,25 +1,21 @@
 // Karma configuration
 
-process.env.CHROME_BIN = require('puppeteer').executablePath();
+process.env.CHROME_BIN = require("puppeteer").executablePath();
 
 module.exports = function(config) {
   config.set({
-
     // base path that will be used to resolve all patterns (eg. files, exclude)
-    basePath: '',
+    basePath: "",
 
     // frameworks to use
     // available frameworks: https://npmjs.org/browse/keyword/karma-adapter
-    frameworks: ['jasmine', "karma-typescript"],
+    frameworks: ["jasmine", "karma-typescript"],
 
     // list of files / patterns to load in the browser
-    files: [
-      'src/**/*.ts'
-    ],
+    files: ["src/**/*.ts"],
 
     // list of files / patterns to exclude
-    exclude: [
-    ],
+    exclude: [],
 
     // preprocess matching files before serving them to the browser
     // available preprocessors: https://npmjs.org/browse/keyword/karma-preprocessor
@@ -30,7 +26,7 @@ module.exports = function(config) {
     // test results reporter to use
     // possible values: 'dots', 'progress'
     // available reporters: https://npmjs.org/browse/keyword/karma-reporter
-    reporters: ['progress', 'coverage', "karma-typescript"],
+    reporters: ["progress", "coverage", "karma-typescript"],
 
     karmaTypescriptConfig: {
       tsconfig: "./tsconfig.json",
@@ -54,7 +50,7 @@ module.exports = function(config) {
 
     // start these browsers
     // available browser launchers: https://npmjs.org/browse/keyword/karma-launcher
-    browsers: ['ChromeHeadless'],
+    browsers: ["ChromeHeadless"],
 
     // Continuous Integration mode
     // if true, Karma captures browsers, runs the tests and exits
@@ -63,5 +59,5 @@ module.exports = function(config) {
     // Concurrency level
     // how many browser should be started simultaneous
     concurrency: Infinity
-  })
-}
+  });
+};

packages/apply-body-checksum-middleware/src/index.spec.ts

@@ -42,7 +42,10 @@ describe("applyChecksumMiddleware", () => {
         "checksumHeader",
         MockHash,
         mockEncoder
-      )(next, {} as any)({
+      )(
+        next,
+        {} as any
+      )({
         request: { ...request, body },
         input: {}
       });
@@ -70,7 +73,10 @@ describe("applyChecksumMiddleware", () => {
         "checksumHeader",
         MockHash,
         mockEncoder
-      )(next, {} as any)({
+      )(
+        next,
+        {} as any
+      )({
         request: {
           ...request,
           body,
@@ -132,7 +138,10 @@ describe("applyChecksumMiddleware", () => {
       MockHash,
       mockEncoder,
       async (stream: ExoticStream) => new Uint8Array(5)
-    )(next, {} as any)({
+    )(
+      next,
+      {} as any
+    )({
       request: {
         ...request,
         body: new ExoticStream()

packages/credential-provider-cognito-identity/src/resolveLogins.ts

@@ -23,12 +23,9 @@ export function resolveLogins(logins: Logins): Promise<ResolvedLogins> {
       [] as Array<Promise<[string, string]>>
     )
   ).then(resolvedPairs =>
-    resolvedPairs.reduce(
-      (logins: ResolvedLogins, [key, value]) => {
-        logins[key] = value;
-        return logins;
-      },
-      {} as ResolvedLogins
-    )
+    resolvedPairs.reduce((logins: ResolvedLogins, [key, value]) => {
+      logins[key] = value;
+      return logins;
+    }, {} as ResolvedLogins)
   );
 }

packages/credential-provider-imds/src/fromContainerMetadata.ts

@@ -82,9 +82,7 @@ function getCmdsUri(): Promise<RequestOptions> {
     if (!parsed.hostname || !(parsed.hostname in GREENGRASS_HOSTS)) {
       return Promise.reject(
         new ProviderError(
-          `${
-            parsed.hostname
-          } is not a valid container metadata service hostname`,
+          `${parsed.hostname} is not a valid container metadata service hostname`,
           false
         )
       );
@@ -93,9 +91,7 @@ function getCmdsUri(): Promise<RequestOptions> {
     if (!parsed.protocol || !(parsed.protocol in GREENGRASS_PROTOCOLS)) {
       return Promise.reject(
         new ProviderError(
-          `${
-            parsed.protocol
-          } is not a valid container metadata service protocol`,
+          `${parsed.protocol} is not a valid container metadata service protocol`,
           false
         )
       );

packages/credential-provider-imds/src/fromInstanceMetadata.ts

@@ -20,10 +20,12 @@ export function fromInstanceMetadata(
 ): CredentialProvider {
   const { timeout, maxRetries } = providerConfigFromInit(init);
   return async () => {
-    const profile = (await retry<string>(
-      async () => await requestFromEc2Imds(timeout),
-      maxRetries
-    )).trim();
+    const profile = (
+      await retry<string>(
+        async () => await requestFromEc2Imds(timeout),
+        maxRetries
+      )
+    ).trim();
 
     return retry(async () => {
       const credsResponse = JSON.parse(

packages/eventstream-marshaller/scripts/buildTestVectorsFixture.js

@@ -1,103 +1,100 @@
-const { Buffer } = require('buffer');
-const {
-    readdirSync,
-    readFileSync,
-    writeFileSync,
-} = require('fs');
-const {
-    dirname,
-    join,
-} = require('path');
+const { Buffer } = require("buffer");
+const { readdirSync, readFileSync, writeFileSync } = require("fs");
+const { dirname, join } = require("path");
 
 const HEADER_TYPES = [
-    'boolean',
-    'boolean',
-    'byte',
-    'short',
-    'integer',
-    'long',
-    'binary',
-    'string',
-    'timestamp',
-    'uuid',
+  "boolean",
+  "boolean",
+  "byte",
+  "short",
+  "integer",
+  "long",
+  "binary",
+  "string",
+  "timestamp",
+  "uuid"
 ];
 
-const vectorsDir = join(dirname(__dirname), 'test_vectors');
-let vectors = '\n';
+const vectorsDir = join(dirname(__dirname), "test_vectors");
+let vectors = "\n";
 
-for (const dirName of ['positive', 'negative']) {
-    const encodedVectorsDir = join(vectorsDir, 'encoded', dirName);
-    const decodedVectorsDir = join(vectorsDir, 'decoded', dirName);
+for (const dirName of ["positive", "negative"]) {
+  const encodedVectorsDir = join(vectorsDir, "encoded", dirName);
+  const decodedVectorsDir = join(vectorsDir, "decoded", dirName);
 
-    for (const vectorName of readdirSync(encodedVectorsDir)) {
-        vectors +=
-`    ${vectorName}: {
-        expectation: '${dirName === 'positive' ? 'success' : 'failure'}',
-        encoded: Uint8Array.from([${
-            readFileSync(join(encodedVectorsDir, vectorName))
-                .map(byte => byte.toString(10))
-                .join(', ')
-        }]),
+  for (const vectorName of readdirSync(encodedVectorsDir)) {
+    vectors += `    ${vectorName}: {
+        expectation: '${dirName === "positive" ? "success" : "failure"}',
+        encoded: Uint8Array.from([${readFileSync(
+          join(encodedVectorsDir, vectorName)
+        )
+          .map(byte => byte.toString(10))
+          .join(", ")}]),
 `;
 
-        if (dirName === 'positive') {
-            const decoded = JSON.parse(
-                readFileSync(join(decodedVectorsDir, vectorName))
-            );
-            const headers = decoded.headers
-                .map(declaration =>
-`               '${declaration.name}': {
+    if (dirName === "positive") {
+      const decoded = JSON.parse(
+        readFileSync(join(decodedVectorsDir, vectorName))
+      );
+      const headers = decoded.headers
+        .map(
+          declaration =>
+            `               '${declaration.name}': {
                     type: '${HEADER_TYPES[declaration.type]}',
                     value: ${headerValue(declaration.type, declaration.value)},
                 },`
-                )
-                .join('\n')
+        )
+        .join("\n");
 
-            vectors +=
-`        decoded: {
+      vectors += `        decoded: {
             headers: {
 ${headers}
             },
-            body: ${writeBuffer(Buffer.from(decoded.payload, 'base64'))},
+            body: ${writeBuffer(Buffer.from(decoded.payload, "base64"))},
         },
-`
-        }
-
-        vectors += "    },\n"
+`;
     }
+
+    vectors += "    },\n";
+  }
 }
 
 writeFileSync(
-    join(dirname(__dirname), 'src', 'TestVectors.fixture.ts'),
-`import { TestVectors } from './vectorTypes.fixture';
+  join(dirname(__dirname), "src", "TestVectors.fixture.ts"),
+  `import { TestVectors } from './vectorTypes.fixture';
 import { Int64 } from './Int64';
 
 export const vectors: TestVectors = {${vectors}};
 `
 );
 
 function headerValue(type, vectorRepresentation) {
-    switch (type) {
-        case 0:
-            return 'true';
-        case 1:
-            return 'false';
-        case 5:
-            return `Int64.fromNumber(${vectorRepresentation})`;
-        case 6:
-            return writeBuffer(Buffer.from(vectorRepresentation, 'base64'));
-        case 7:
-            return `'${Buffer.from(vectorRepresentation, 'base64').toString()}'`;
-        case 8:
-            return `new Date(${vectorRepresentation})`;
-        case 9:
-            const hex = Buffer.from(vectorRepresentation, 'base64').toString('hex');
-            return `'${hex.substr(0, 8)}-${hex.substr(8, 4)}-${hex.substr(12, 4)}-${hex.substr(16, 4)}-${hex.substr(20)}'`
-        default:
-            return vectorRepresentation;
-    }
+  switch (type) {
+    case 0:
+      return "true";
+    case 1:
+      return "false";
+    case 5:
+      return `Int64.fromNumber(${vectorRepresentation})`;
+    case 6:
+      return writeBuffer(Buffer.from(vectorRepresentation, "base64"));
+    case 7:
+      return `'${Buffer.from(vectorRepresentation, "base64").toString()}'`;
+    case 8:
+      return `new Date(${vectorRepresentation})`;
+    case 9:
+      const hex = Buffer.from(vectorRepresentation, "base64").toString("hex");
+      return `'${hex.substr(0, 8)}-${hex.substr(8, 4)}-${hex.substr(
+        12,
+        4
+      )}-${hex.substr(16, 4)}-${hex.substr(20)}'`;
+    default:
+      return vectorRepresentation;
+  }
 }
 
 function writeBuffer(buffer) {
-    return `Uint8Array.from([${buffer.map(byte => byte.toString(10)).join(', ')}])`;
+  return `Uint8Array.from([${buffer
+    .map(byte => byte.toString(10))
+    .join(", ")}])`;
 }