Initial prettier formatted files

2020-02-24 13:44:50 -05:00
parent 1543c990ca
commit 777e629b3d
83 changed files with 18556 additions and 19258 deletions
--- a/assets/js/curlparser.js
+++ b/assets/js/curlparser.js
@@ -1,6 +1,6 @@
-import * as cookie from "cookie";
-import * as URL from "url";
-import * as querystring from "querystring";
+import * as cookie from 'cookie'
+import * as URL from 'url'
+import * as querystring from 'querystring'

 /**
 * given this: [ 'msg1=value1', 'msg2=value2' ]
@@ -8,219 +8,215 @@ import * as querystring from "querystring";
 * @param dataArguments
 */
 const joinDataArguments = dataArguments => {
-  let data = "";
+  let data = ''
  dataArguments.forEach((argument, i) => {
    if (i === 0) {
-      data += argument;
+      data += argument
    } else {
-      data += `&${argument}`;
+      data += `&${argument}`
    }
-  });
-  return data;
-};
+  })
+  return data
+}

 const parseCurlCommand = curlCommand => {
-  let newlineFound = /\r|\n/.exec(curlCommand);
+  let newlineFound = /\r|\n/.exec(curlCommand)
  if (newlineFound) {
    // remove newlines
-    curlCommand = curlCommand.replace(/\r|\n/g, "");
+    curlCommand = curlCommand.replace(/\r|\n/g, '')
  }
  // yargs parses -XPOST as separate arguments. just prescreen for it.
-  curlCommand = curlCommand.replace(/ -XPOST/, " -X POST");
-  curlCommand = curlCommand.replace(/ -XGET/, " -X GET");
-  curlCommand = curlCommand.replace(/ -XPUT/, " -X PUT");
-  curlCommand = curlCommand.replace(/ -XPATCH/, " -X PATCH");
-  curlCommand = curlCommand.replace(/ -XDELETE/, " -X DELETE");
-  curlCommand = curlCommand.trim();
-  let parsedArguments = require("yargs-parser")(curlCommand);
-  let cookieString;
-  let cookies;
-  let url = parsedArguments._[1];
+  curlCommand = curlCommand.replace(/ -XPOST/, ' -X POST')
+  curlCommand = curlCommand.replace(/ -XGET/, ' -X GET')
+  curlCommand = curlCommand.replace(/ -XPUT/, ' -X PUT')
+  curlCommand = curlCommand.replace(/ -XPATCH/, ' -X PATCH')
+  curlCommand = curlCommand.replace(/ -XDELETE/, ' -X DELETE')
+  curlCommand = curlCommand.trim()
+  let parsedArguments = require('yargs-parser')(curlCommand)
+  let cookieString
+  let cookies
+  let url = parsedArguments._[1]
  if (!url) {
    for (let argName in parsedArguments) {
-      if (typeof parsedArguments[argName] === "string") {
-        if (["http", "www."].includes(parsedArguments[argName])) {
-          url = parsedArguments[argName];
+      if (typeof parsedArguments[argName] === 'string') {
+        if (['http', 'www.'].includes(parsedArguments[argName])) {
+          url = parsedArguments[argName]
        }
      }
    }
  }
-  let headers;
+  let headers

  const parseHeaders = headerFieldName => {
    if (parsedArguments[headerFieldName]) {
      if (!headers) {
-        headers = {};
+        headers = {}
      }
      if (!Array.isArray(parsedArguments[headerFieldName])) {
-        parsedArguments[headerFieldName] = [parsedArguments[headerFieldName]];
+        parsedArguments[headerFieldName] = [parsedArguments[headerFieldName]]
      }
      parsedArguments[headerFieldName].forEach(header => {
-        if (header.includes("Cookie")) {
+        if (header.includes('Cookie')) {
          // stupid javascript tricks: closure
-          cookieString = header;
+          cookieString = header
        } else {
-          let colonIndex = header.indexOf(":");
-          let headerName = header.substring(0, colonIndex);
-          let headerValue = header.substring(colonIndex + 1).trim();
-          headers[headerName] = headerValue;
+          let colonIndex = header.indexOf(':')
+          let headerName = header.substring(0, colonIndex)
+          let headerValue = header.substring(colonIndex + 1).trim()
+          headers[headerName] = headerValue
        }
-      });
+      })
    }
-  };
+  }

-  parseHeaders("H");
-  parseHeaders("header");
+  parseHeaders('H')
+  parseHeaders('header')
  if (parsedArguments.A) {
    if (!headers) {
-      headers = [];
+      headers = []
    }
-    headers["User-Agent"] = parsedArguments.A;
-  } else if (parsedArguments["user-agent"]) {
+    headers['User-Agent'] = parsedArguments.A
+  } else if (parsedArguments['user-agent']) {
    if (!headers) {
-      headers = [];
+      headers = []
    }
-    headers["User-Agent"] = parsedArguments["user-agent"];
+    headers['User-Agent'] = parsedArguments['user-agent']
  }

  if (parsedArguments.b) {
-    cookieString = parsedArguments.b;
+    cookieString = parsedArguments.b
  }
  if (parsedArguments.cookie) {
-    cookieString = parsedArguments.cookie;
+    cookieString = parsedArguments.cookie
  }
-  let multipartUploads;
+  let multipartUploads
  if (parsedArguments.F) {
-    multipartUploads = {};
+    multipartUploads = {}
    if (!Array.isArray(parsedArguments.F)) {
-      parsedArguments.F = [parsedArguments.F];
+      parsedArguments.F = [parsedArguments.F]
    }
    parsedArguments.F.forEach(multipartArgument => {
      // input looks like key=value. value could be json or a file path prepended with an @
-      const [key, value] = multipartArgument.split("=", 2);
-      multipartUploads[key] = value;
-    });
+      const [key, value] = multipartArgument.split('=', 2)
+      multipartUploads[key] = value
+    })
  }
  if (cookieString) {
    const cookieParseOptions = {
-      decode: s => s
-    };
+      decode: s => s,
+    }
    // separate out cookie headers into separate data structure
    // note: cookie is case insensitive
-    cookies = cookie.parse(
-      cookieString.replace(/^Cookie: /gi, ""),
-      cookieParseOptions
-    );
+    cookies = cookie.parse(cookieString.replace(/^Cookie: /gi, ''), cookieParseOptions)
  }
-  let method;
-  if (parsedArguments.X === "POST") {
-    method = "post";
-  } else if (parsedArguments.X === "PUT" || parsedArguments["T"]) {
-    method = "put";
-  } else if (parsedArguments.X === "PATCH") {
-    method = "patch";
-  } else if (parsedArguments.X === "DELETE") {
-    method = "delete";
-  } else if (parsedArguments.X === "OPTIONS") {
-    method = "options";
+  let method
+  if (parsedArguments.X === 'POST') {
+    method = 'post'
+  } else if (parsedArguments.X === 'PUT' || parsedArguments['T']) {
+    method = 'put'
+  } else if (parsedArguments.X === 'PATCH') {
+    method = 'patch'
+  } else if (parsedArguments.X === 'DELETE') {
+    method = 'delete'
+  } else if (parsedArguments.X === 'OPTIONS') {
+    method = 'options'
  } else if (
-    (parsedArguments["d"] ||
-      parsedArguments["data"] ||
-      parsedArguments["data-ascii"] ||
-      parsedArguments["data-binary"] ||
-      parsedArguments["F"] ||
-      parsedArguments["form"]) &&
-    !(parsedArguments["G"] || parsedArguments["get"])
+    (parsedArguments['d'] ||
+      parsedArguments['data'] ||
+      parsedArguments['data-ascii'] ||
+      parsedArguments['data-binary'] ||
+      parsedArguments['F'] ||
+      parsedArguments['form']) &&
+    !(parsedArguments['G'] || parsedArguments['get'])
  ) {
-    method = "post";
-  } else if (parsedArguments["I"] || parsedArguments["head"]) {
-    method = "head";
+    method = 'post'
+  } else if (parsedArguments['I'] || parsedArguments['head']) {
+    method = 'head'
  } else {
-    method = "get";
+    method = 'get'
  }

-  let compressed = !!parsedArguments.compressed;
-  let urlObject = URL.parse(url); // eslint-disable-line
+  let compressed = !!parsedArguments.compressed
+  let urlObject = URL.parse(url) // eslint-disable-line

  // if GET request with data, convert data to query string
  // NB: the -G flag does not change the http verb. It just moves the data into the url.
-  if (parsedArguments["G"] || parsedArguments["get"]) {
-    urlObject.query = urlObject.query ? urlObject.query : "";
-    let option =
-      "d" in parsedArguments ? "d" : "data" in parsedArguments ? "data" : null;
+  if (parsedArguments['G'] || parsedArguments['get']) {
+    urlObject.query = urlObject.query ? urlObject.query : ''
+    let option = 'd' in parsedArguments ? 'd' : 'data' in parsedArguments ? 'data' : null
    if (option) {
-      let urlQueryString = "";
+      let urlQueryString = ''

-      if (!url.includes("?")) {
-        url += "?";
+      if (!url.includes('?')) {
+        url += '?'
      } else {
-        urlQueryString += "&";
+        urlQueryString += '&'
      }

-      if (typeof parsedArguments[option] === "object") {
-        urlQueryString += parsedArguments[option].join("&");
+      if (typeof parsedArguments[option] === 'object') {
+        urlQueryString += parsedArguments[option].join('&')
      } else {
-        urlQueryString += parsedArguments[option];
+        urlQueryString += parsedArguments[option]
      }
-      urlObject.query += urlQueryString;
-      url += urlQueryString;
-      delete parsedArguments[option];
+      urlObject.query += urlQueryString
+      url += urlQueryString
+      delete parsedArguments[option]
    }
  }
  let query = querystring.parse(urlObject.query, null, null, {
-    maxKeys: 10000
-  });
+    maxKeys: 10000,
+  })

-  urlObject.search = null; // Clean out the search/query portion.
+  urlObject.search = null // Clean out the search/query portion.
  const request = {
    url,
-    urlWithoutQuery: URL.format(urlObject)
-  };
+    urlWithoutQuery: URL.format(urlObject),
+  }
  if (compressed) {
-    request["compressed"] = true;
+    request['compressed'] = true
  }

  if (Object.keys(query).length > 0) {
-    request.query = query;
+    request.query = query
  }
  if (headers) {
-    request.headers = headers;
+    request.headers = headers
  }
-  request["method"] = method;
+  request['method'] = method

  if (cookies) {
-    request.cookies = cookies;
-    request.cookieString = cookieString.replace("Cookie: ", "");
+    request.cookies = cookies
+    request.cookieString = cookieString.replace('Cookie: ', '')
  }
  if (multipartUploads) {
-    request.multipartUploads = multipartUploads;
+    request.multipartUploads = multipartUploads
  }
  if (parsedArguments.data) {
-    request.data = parsedArguments.data;
-  } else if (parsedArguments["data-binary"]) {
-    request.data = parsedArguments["data-binary"];
-    request.isDataBinary = true;
-  } else if (parsedArguments["d"]) {
-    request.data = parsedArguments["d"];
-  } else if (parsedArguments["data-ascii"]) {
-    request.data = parsedArguments["data-ascii"];
+    request.data = parsedArguments.data
+  } else if (parsedArguments['data-binary']) {
+    request.data = parsedArguments['data-binary']
+    request.isDataBinary = true
+  } else if (parsedArguments['d']) {
+    request.data = parsedArguments['d']
+  } else if (parsedArguments['data-ascii']) {
+    request.data = parsedArguments['data-ascii']
  }

-  if (parsedArguments["u"]) {
-    request.auth = parsedArguments["u"];
+  if (parsedArguments['u']) {
+    request.auth = parsedArguments['u']
  }
-  if (parsedArguments["user"]) {
-    request.auth = parsedArguments["user"];
+  if (parsedArguments['user']) {
+    request.auth = parsedArguments['user']
  }
  if (Array.isArray(request.data)) {
-    request.dataArray = request.data;
-    request.data = joinDataArguments(request.data);
+    request.dataArray = request.data
+    request.data = joinDataArguments(request.data)
  }

-  if (parsedArguments["k"] || parsedArguments["insecure"]) {
-    request.insecure = true;
+  if (parsedArguments['k'] || parsedArguments['insecure']) {
+    request.insecure = true
  }
-  return request;
-};
+  return request
+}

-export default parseCurlCommand;
+export default parseCurlCommand
--- a/assets/js/oauth.js
+++ b/assets/js/oauth.js
@@ -1,4 +1,4 @@
-const redirectUri = `${window.location.origin}/`;
+const redirectUri = `${window.location.origin}/`

 // GENERAL HELPER FUNCTIONS

@@ -13,23 +13,23 @@ const redirectUri = `${window.location.origin}/`;
 const sendPostRequest = async (url, params) => {
  const body = Object.keys(params)
    .map(key => `${key}=${params[key]}`)
-    .join("&");
+    .join('&')
  const options = {
-    method: "post",
+    method: 'post',
    headers: {
-      "Content-type": "application/x-www-form-urlencoded; charset=UTF-8"
+      'Content-type': 'application/x-www-form-urlencoded; charset=UTF-8',
    },
-    body
-  };
-  try {
-    const response = await fetch(url, options);
-    const data = await response.json();
-    return data;
-  } catch (err) {
-    console.error("Request failed", err);
-    throw err;
+    body,
  }
-};
+  try {
+    const response = await fetch(url, options)
+    const data = await response.json()
+    return data
+  } catch (err) {
+    console.error('Request failed', err)
+    throw err
+  }
+}

 /**
 * Parse a query string into an object
@@ -39,16 +39,13 @@ const sendPostRequest = async (url, params) => {
 */

 const parseQueryString = searchQuery => {
-  if (searchQuery === "") {
-    return {};
+  if (searchQuery === '') {
+    return {}
  }
-  const segments = searchQuery.split("&").map(s => s.split("="));
-  const queryString = segments.reduce(
-    (obj, el) => ({ ...obj, [el[0]]: el[1] }),
-    {}
-  );
-  return queryString;
-};
+  const segments = searchQuery.split('&').map(s => s.split('='))
+  const queryString = segments.reduce((obj, el) => ({ ...obj, [el[0]]: el[1] }), {})
+  return queryString
+}

 /**
 * Get OAuth configuration from OpenID Discovery endpoint
@@ -58,20 +55,20 @@ const parseQueryString = searchQuery => {

 const getTokenConfiguration = async endpoint => {
  const options = {
-    method: "GET",
+    method: 'GET',
    headers: {
-      "Content-type": "application/json"
-    }
-  };
-  try {
-    const response = await fetch(endpoint, options);
-    const config = await response.json();
-    return config;
-  } catch (err) {
-    console.error("Request failed", err);
-    throw err;
+      'Content-type': 'application/json',
+    },
  }
-};
+  try {
+    const response = await fetch(endpoint, options)
+    const config = await response.json()
+    return config
+  } catch (err) {
+    console.error('Request failed', err)
+    throw err
+  }
+}

 // PKCE HELPER FUNCTIONS

@@ -82,10 +79,10 @@ const getTokenConfiguration = async endpoint => {
 */

 const generateRandomString = () => {
-  const array = new Uint32Array(28);
-  window.crypto.getRandomValues(array);
-  return Array.from(array, dec => `0${dec.toString(16)}`.substr(-2)).join("");
-};
+  const array = new Uint32Array(28)
+  window.crypto.getRandomValues(array)
+  return Array.from(array, dec => `0${dec.toString(16)}`.substr(-2)).join('')
+}

 /**
 * Calculate the SHA256 hash of the input text
@@ -94,10 +91,10 @@ const generateRandomString = () => {
 */

 const sha256 = plain => {
-  const encoder = new TextEncoder();
-  const data = encoder.encode(plain);
-  return window.crypto.subtle.digest("SHA-256", data);
-};
+  const encoder = new TextEncoder()
+  const data = encoder.encode(plain)
+  return window.crypto.subtle.digest('SHA-256', data)
+}

 /**
 * Encodes the input string into Base64 format
@@ -113,9 +110,9 @@ const base64urlencode = (
  // Then convert the base64 encoded to base64url encoded
  //   (replace + with -, replace / with _, trim trailing =)
  btoa(String.fromCharCode.apply(null, new Uint8Array(str)))
-    .replace(/\+/g, "-")
-    .replace(/\//g, "_")
-    .replace(/=+$/, "");
+    .replace(/\+/g, '-')
+    .replace(/\//g, '_')
+    .replace(/=+$/, '')

 /**
 * Return the base64-urlencoded sha256 hash for the PKCE challenge
@@ -125,9 +122,9 @@ const base64urlencode = (
 */

 const pkceChallengeFromVerifier = async v => {
-  const hashed = await sha256(v);
-  return base64urlencode(hashed);
-};
+  const hashed = await sha256(v)
+  return base64urlencode(hashed)
+}

 // OAUTH REQUEST

@@ -144,32 +141,29 @@ const tokenRequest = async ({
  authUrl,
  accessTokenUrl,
  clientId,
-  scope
+  scope,
 }) => {
  // Check oauth configuration
-  if (oidcDiscoveryUrl !== "") {
-    const {
-      authorization_endpoint,
-      token_endpoint
-    } = await getTokenConfiguration(oidcDiscoveryUrl);
-    authUrl = authorization_endpoint;
-    accessTokenUrl = token_endpoint;
+  if (oidcDiscoveryUrl !== '') {
+    const { authorization_endpoint, token_endpoint } = await getTokenConfiguration(oidcDiscoveryUrl)
+    authUrl = authorization_endpoint
+    accessTokenUrl = token_endpoint
  }

  // Store oauth information
-  localStorage.setItem("token_endpoint", accessTokenUrl);
-  localStorage.setItem("client_id", clientId);
+  localStorage.setItem('token_endpoint', accessTokenUrl)
+  localStorage.setItem('client_id', clientId)

  // Create and store a random state value
-  const state = generateRandomString();
-  localStorage.setItem("pkce_state", state);
+  const state = generateRandomString()
+  localStorage.setItem('pkce_state', state)

  // Create and store a new PKCE code_verifier (the plaintext random secret)
-  const code_verifier = generateRandomString();
-  localStorage.setItem("pkce_code_verifier", code_verifier);
+  const code_verifier = generateRandomString()
+  localStorage.setItem('pkce_code_verifier', code_verifier)

  // Hash and base64-urlencode the secret to use as the challenge
-  const code_challenge = await pkceChallengeFromVerifier(code_verifier);
+  const code_challenge = await pkceChallengeFromVerifier(code_verifier)

  // Build the authorization URL
  const buildUrl = () =>
@@ -177,15 +171,13 @@ const tokenRequest = async ({
      clientId
    )}&state=${encodeURIComponent(state)}&scope=${encodeURIComponent(
      scope
-    )}&redirect_uri=${encodeURIComponent(
-      redirectUri
-    )}&code_challenge=${encodeURIComponent(
+    )}&redirect_uri=${encodeURIComponent(redirectUri)}&code_challenge=${encodeURIComponent(
      code_challenge
-    )}&code_challenge_method=S256`;
+    )}&code_challenge_method=S256`

  // Redirect to the authorization server
-  window.location = buildUrl();
-};
+  window.location = buildUrl()
+}

 // OAUTH REDIRECT HANDLING

@@ -197,42 +189,39 @@ const tokenRequest = async ({
 */

 const oauthRedirect = async () => {
-  let tokenResponse = "";
-  let q = parseQueryString(window.location.search.substring(1));
+  let tokenResponse = ''
+  let q = parseQueryString(window.location.search.substring(1))
  // Check if the server returned an error string
  if (q.error) {
-    alert(`Error returned from authorization server: ${q.error}`);
+    alert(`Error returned from authorization server: ${q.error}`)
  }
  // If the server returned an authorization code, attempt to exchange it for an access token
  if (q.code) {
    // Verify state matches what we set at the beginning
-    if (localStorage.getItem("pkce_state") != q.state) {
-      alert("Invalid state");
+    if (localStorage.getItem('pkce_state') != q.state) {
+      alert('Invalid state')
    } else {
      try {
        // Exchange the authorization code for an access token
-        tokenResponse = await sendPostRequest(
-          localStorage.getItem("token_endpoint"),
-          {
-            grant_type: "authorization_code",
-            code: q.code,
-            client_id: localStorage.getItem("client_id"),
-            redirect_uri: redirectUri,
-            code_verifier: localStorage.getItem("pkce_code_verifier")
-          }
-        );
+        tokenResponse = await sendPostRequest(localStorage.getItem('token_endpoint'), {
+          grant_type: 'authorization_code',
+          code: q.code,
+          client_id: localStorage.getItem('client_id'),
+          redirect_uri: redirectUri,
+          code_verifier: localStorage.getItem('pkce_code_verifier'),
+        })
      } catch (err) {
-        console.log(`${error.error}\n\n${error.error_description}`);
+        console.log(`${error.error}\n\n${error.error_description}`)
      }
    }
    // Clean these up since we don't need them anymore
-    localStorage.removeItem("pkce_state");
-    localStorage.removeItem("pkce_code_verifier");
-    localStorage.removeItem("token_endpoint");
-    localStorage.removeItem("client_id");
-    return tokenResponse;
+    localStorage.removeItem('pkce_state')
+    localStorage.removeItem('pkce_code_verifier')
+    localStorage.removeItem('token_endpoint')
+    localStorage.removeItem('client_id')
+    return tokenResponse
  }
-  return tokenResponse;
-};
+  return tokenResponse
+}

-export { tokenRequest, oauthRedirect };
+export { tokenRequest, oauthRedirect }
--- a/assets/js/pwa.js
+++ b/assets/js/pwa.js
@@ -2,55 +2,50 @@ export default () => {
  //*** Determine whether or not the PWA has been installed. ***//

  // Step 1: Check local storage
-  let pwaInstalled = localStorage.getItem("pwaInstalled") === "yes";
+  let pwaInstalled = localStorage.getItem('pwaInstalled') === 'yes'

  // Step 2: Check if the display-mode is standalone. (Only permitted for PWAs.)
-  if (
-    !pwaInstalled &&
-    window.matchMedia("(display-mode: standalone)").matches
-  ) {
-    localStorage.setItem("pwaInstalled", "yes");
-    pwaInstalled = true;
+  if (!pwaInstalled && window.matchMedia('(display-mode: standalone)').matches) {
+    localStorage.setItem('pwaInstalled', 'yes')
+    pwaInstalled = true
  }

  // Step 3: Check if the navigator is in standalone mode. (Again, only permitted for PWAs.)
  if (!pwaInstalled && window.navigator.standalone === true) {
-    localStorage.setItem("pwaInstalled", "yes");
-    pwaInstalled = true;
+    localStorage.setItem('pwaInstalled', 'yes')
+    pwaInstalled = true
  }

  //*** If the PWA has not been installed, show the install PWA prompt.. ***//
-  let deferredPrompt = null;
-  window.addEventListener("beforeinstallprompt", event => {
-    deferredPrompt = event;
+  let deferredPrompt = null
+  window.addEventListener('beforeinstallprompt', event => {
+    deferredPrompt = event

    // Show the install button if the prompt appeared.
    if (!pwaInstalled) {
-      document.querySelector("#installPWA").style.display = "inline-flex";
+      document.querySelector('#installPWA').style.display = 'inline-flex'
    }
-  });
+  })

  // When the app is installed, remove install prompts.
-  window.addEventListener("appinstalled", event => {
-    localStorage.setItem("pwaInstalled", "yes");
-    pwaInstalled = true;
-    document.getElementById("installPWA").style.display = "none";
-  });
+  window.addEventListener('appinstalled', event => {
+    localStorage.setItem('pwaInstalled', 'yes')
+    pwaInstalled = true
+    document.getElementById('installPWA').style.display = 'none'
+  })

  // When the app is uninstalled, add the prompts back
  return async () => {
    if (deferredPrompt) {
-      deferredPrompt.prompt();
-      let outcome = await deferredPrompt.userChoice;
+      deferredPrompt.prompt()
+      let outcome = await deferredPrompt.userChoice

-      if (outcome === "accepted") {
-        console.log("Postwoman was installed successfully.");
+      if (outcome === 'accepted') {
+        console.log('Postwoman was installed successfully.')
      } else {
-        console.log(
-          "Postwoman could not be installed. (Installation rejected by user.)"
-        );
+        console.log('Postwoman could not be installed. (Installation rejected by user.)')
      }
-      deferredPrompt = null;
+      deferredPrompt = null
    }
-  };
-};
+  }
+}