@inboxsdk/core 0.2.27 → 0.2.28-alpha.1

package/src/injected-js/setup-data-exposer.js

@@ -0,0 +1,187 @@
+/* @flow */
+
+import find from 'lodash/find';
+import * as logger from './injected-logger';
+import waitFor from '../platform-implementation-js/lib/wait-for';
+
+declare var GLOBALS: any[];
+declare var gbar: { _CONFIG: any[] };
+
+function stupidToBool(stupid: any): boolean {
+  switch ('' + stupid) {
+    case '1':
+    case 't':
+    case 'true':
+      return true;
+    default:
+      return false;
+  }
+}
+
+function getSettingValue(settings: any[], name: string): boolean {
+  var entry = find(settings, (setting) => setting[0] === name);
+  return entry ? stupidToBool(entry[1]) : false;
+}
+
+function getContext() {
+  let context = global;
+  try {
+    // our current tab has globals defined
+    if (context.GLOBALS) return context;
+
+    // we don't, let's see if we have access to opener (i.e. we are a new compose/thread view)
+    if (global.opener && global.opener.top) {
+      // try to get href
+      // if the opener is not gmail (i.e. you clicked on a mailto link on craigslist) then this will throw an error
+      global.opener.top.location.href;
+      context = global.opener.top;
+    }
+  } catch (err) {
+    context = global; //we got an error from requesting global.opener.top.location.href;
+  }
+
+  return context;
+}
+
+export default function setupDataExposer() {
+  let context;
+  waitFor(() => {
+    context = getContext();
+    return context && (context.GLOBALS || context.gbar);
+  })
+    .then(() => {
+      if (!context) return;
+      var userEmail = context.GLOBALS
+        ? context.GLOBALS[10]
+        : context.gbar._CONFIG[0][10][5];
+      (document.head: any).setAttribute(
+        'data-inboxsdk-user-email-address',
+        userEmail
+      );
+
+      var userLanguage: string = context.GLOBALS
+        ? context.GLOBALS[4].split('.')[1]
+        : context.gbar._CONFIG[0][0][4];
+      (document.head: any).setAttribute(
+        'data-inboxsdk-user-language',
+        userLanguage
+      );
+
+      (document.head: any).setAttribute(
+        'data-inboxsdk-using-sync-api',
+        context.GM_SPT_ENABLED
+      );
+
+      if (context.GLOBALS) {
+        // Gmail
+        (document.head: any).setAttribute(
+          'data-inboxsdk-ik-value',
+          context.GLOBALS[9]
+        );
+        (document.head: any).setAttribute(
+          'data-inboxsdk-action-token-value',
+          context.GM_ACTION_TOKEN
+        );
+
+        var globalSettingsHolder = find(
+          context.GLOBALS[17],
+          (item) => item[0] === 'p'
+        );
+
+        if (!globalSettingsHolder) {
+          // global settings doesn't exist on gmail v2, so we don't need to log this anymore
+          return;
+        } else {
+          var globalSettings = globalSettingsHolder[1];
+          {
+            var previewPaneLabEnabled = getSettingValue(
+              globalSettings,
+              'bx_lab_1252'
+            );
+            var previewPaneEnabled = getSettingValue(globalSettings, 'bx_spa');
+            var previewPaneVertical = getSettingValue(globalSettings, 'bx_spo');
+            var previewPaneMode =
+              previewPaneLabEnabled && previewPaneEnabled
+                ? previewPaneVertical
+                  ? 'vertical'
+                  : 'horizontal'
+                : 'none';
+            (document.head: any).setAttribute(
+              'data-inboxsdk-user-preview-pane-mode',
+              previewPaneMode
+            );
+          }
+        }
+      } else {
+        // Inbox
+        const preloadDataSearchString = 'window.BT_EmbeddedAppData=[';
+        const preloadScript = find(
+          document.querySelectorAll('script:not([src])'),
+          (script) =>
+            script.text &&
+            script.text.slice(0, 500).indexOf(preloadDataSearchString) > -1
+        );
+        if (!preloadScript) {
+          logger.error(
+            new Error('Could not read preloaded BT_EmbeddedAppData')
+          );
+        } else {
+          const { text } = preloadScript;
+          const firstBracket = text.indexOf('window.BT_EmbeddedAppData=[');
+          let lastBracket = text.indexOf(']\n;', firstBracket);
+          if (lastBracket === -1) {
+            // I have only seen the case where there is a new line between the
+            // closing bracket and the semicolon, but want to be defensive in
+            // case that changes.
+            lastBracket = text.indexOf('];', firstBracket);
+          }
+          const preloadData = JSON.parse(
+            text.slice(
+              firstBracket + preloadDataSearchString.length - 1,
+              lastBracket + 1
+            )
+          );
+
+          const ikValue = preloadData[11];
+          if (typeof ikValue !== 'string') {
+            logger.error(new Error('Could not find valid ikValue'));
+          } else {
+            (document.head: any).setAttribute(
+              'data-inboxsdk-ik-value',
+              ikValue
+            );
+          }
+
+          const xsrfToken = preloadData[12];
+          if (typeof xsrfToken !== 'string') {
+            logger.error(new Error('Could not find valid xsrfToken'));
+          } else {
+            (document.head: any).setAttribute(
+              'data-inboxsdk-xsrf-token',
+              xsrfToken
+            );
+          }
+        }
+      }
+    })
+    .catch((err) => {
+      function getStatus() {
+        return {
+          hasGLOBALS: !!context.GLOBALS,
+          hasGbar: !!context.gbar,
+        };
+      }
+      var startStatus = getStatus();
+      var waitTime = 180 * 1000;
+      setTimeout(() => {
+        var laterStatus = getStatus();
+        logger.eventSdkPassive('waitfor global data', {
+          startStatus,
+          waitTime,
+          laterStatus,
+        });
+      }, waitTime);
+      throw err;
+    })
+    .catch(logger.error);
+}

package/src/injected-js/setup-error-silencer.js

@@ -0,0 +1,25 @@
+/* @flow */
+
+export default function setupErrorSilencer() {
+  var oldErrorHandlers = [];
+
+  document.addEventListener(
+    'inboxSDKsilencePageErrors',
+    function (event: Event) {
+      oldErrorHandlers.push(window.onerror);
+      window.onerror = function (...args) {
+        if (process.env.NODE_ENV !== 'production') {
+          console.error('(Silenced in production) Page error:', ...args); //eslint-disable-line no-console
+        }
+        return true;
+      };
+    }
+  );
+
+  document.addEventListener(
+    'inboxSDKunsilencePageErrors',
+    function (event: Event) {
+      window.onerror = oldErrorHandlers.pop();
+    }
+  );
+}

package/src/injected-js/setup-event-reemitter.js

@@ -0,0 +1,52 @@
+/* @flow */
+
+export default function setupEventReemitter() {
+  // Webkit has bugs that stop certain types of events from being created. We
+  // can manually fake creation of those events, but we have to do it from
+  // inside the page's script if we want the page's script to see the modified
+  // properties.
+  // https://bugs.webkit.org/show_bug.cgi?id=16735
+  // https://code.google.com/p/chromium/issues/detail?id=327853
+  document.addEventListener('inboxsdk_event_relay', function (event: Object) {
+    const newEvent = document.createEvent('Events');
+    (newEvent: any).initEvent(
+      event.detail.type,
+      event.detail.bubbles,
+      event.detail.cancelable
+    );
+    Object.assign(newEvent, event.detail.props);
+    if (event.detail.dataTransfer) {
+      const { files, fileNames } = event.detail.dataTransfer;
+      if (fileNames) {
+        fileNames.forEach((fileName, i) => {
+          const file = files[i];
+          if (typeof file.name !== 'string') {
+            file.name = fileName;
+          }
+        });
+      }
+      (newEvent: any).dataTransfer = {
+        dropEffect: 'none',
+        effectAllowed: 'all',
+        files,
+        items: files.map(({ type }, i) => ({
+          kind: 'file',
+          type,
+          getAsFile() {
+            return files[i];
+          },
+          getAsString() {
+            throw new Error('getAsString not supported');
+          },
+        })),
+        types: ['Files'],
+        getData() {
+          return '';
+        },
+        setData() {},
+        setDragImage() {},
+      };
+    }
+    event.target.dispatchEvent(newEvent);
+  });
+}

package/src/injected-js/setupCustomViewEventAssassin.d.ts

@@ -0,0 +1,2 @@
+export default function setupCustomViewEventAssassin(): void;
+//# sourceMappingURL=setupCustomViewEventAssassin.d.ts.map

package/src/injected-js/setupCustomViewEventAssassin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"setupCustomViewEventAssassin.d.ts","sourceRoot":"","sources":["../../../../src/injected-js/setupCustomViewEventAssassin.ts"],"names":[],"mappings":"AA4GA,MAAM,CAAC,OAAO,UAAU,4BAA4B,SAEnD"}

package/src/injected-js/setupInboxCustomViewLinkFixer.js

@@ -0,0 +1,31 @@
+/* @flow */
+
+import closest from 'closest-ng';
+
+export default function setupInboxCustomViewLinkFixer() {
+  const allowedStartTerms = new Set();
+
+  document.addEventListener(
+    'inboxSDKregisterAllowedHashLinkStartTerm',
+    function (event: Event) {
+      const term = (event: any).detail.term;
+      allowedStartTerms.add(term);
+    }
+  );
+
+  document.addEventListener(
+    'click',
+    function (event: MouseEvent) {
+      const target = event.target;
+      if (!(target instanceof HTMLElement)) return;
+      const anchor = closest(target, 'a[href^="#"]');
+      if (!anchor || !(anchor instanceof HTMLAnchorElement)) return;
+      const m = /^#([^/]+)/.exec(anchor.getAttribute('href') || '');
+      if (!m) return;
+      const startTerm = m[1];
+      if (!allowedStartTerms.has(startTerm)) return;
+      (event: any).preventDefault = () => {};
+    },
+    true
+  );
+}

package/src/injected-js/setupPushStateListener.js

@@ -0,0 +1,16 @@
+/* @flow */
+
+export default function setupPushStateListener() {
+  const origPushState = history.pushState;
+  (history: any).pushState = function (...args) {
+    const ret = origPushState.apply(this, args);
+    document.dispatchEvent(
+      new CustomEvent('inboxSDKpushState', {
+        bubbles: false,
+        cancelable: false,
+        detail: { args },
+      })
+    );
+    return ret;
+  };
+}

package/src/injected-js/xhr-helper.js

@@ -0,0 +1,86 @@
+/* @flow */
+
+import ajax from '../common/ajax';
+
+export default function xhrHelper() {
+  document.addEventListener('inboxSDKpageAjax', function (event: any) {
+    const id = event.detail.id;
+    const opts = {
+      url: event.detail.url,
+      method: event.detail.method,
+      headers: event.detail.headers,
+      xhrFields: event.detail.xhrFields,
+      data: event.detail.data,
+    };
+
+    // It's important to use fetch when possible because it's needed for
+    // getDownloadURL() in Gmail v2: Gmail v2's ServiceWorker in Chrome causes
+    // xhr.responseURL to have the wrong value (possibly a Chrome bug).
+    if (global.fetch) {
+      (async () => {
+        const response = await fetch(opts.url, {
+          method: opts.method || 'GET',
+          credentials: 'include',
+        });
+        document.dispatchEvent(
+          new CustomEvent('inboxSDKpageAjaxDone', {
+            bubbles: false,
+            cancelable: false,
+            detail: {
+              id,
+              error: false,
+              text: await response.text(),
+              responseURL: response.url,
+            },
+          })
+        );
+      })().catch((err) => {
+        document.dispatchEvent(
+          new CustomEvent('inboxSDKpageAjaxDone', {
+            bubbles: false,
+            cancelable: false,
+            detail: {
+              id,
+              error: true,
+              message: err && err.message,
+              stack: err && err.stack,
+              status: err && err.xhr && err.xhr.status,
+            },
+          })
+        );
+      });
+    } else {
+      ajax(opts).then(
+        ({ text, xhr }) => {
+          document.dispatchEvent(
+            new CustomEvent('inboxSDKpageAjaxDone', {
+              bubbles: false,
+              cancelable: false,
+              detail: {
+                id,
+                error: false,
+                text,
+                responseURL: (xhr: any).responseURL,
+              },
+            })
+          );
+        },
+        (err) => {
+          document.dispatchEvent(
+            new CustomEvent('inboxSDKpageAjaxDone', {
+              bubbles: false,
+              cancelable: false,
+              detail: {
+                id,
+                error: true,
+                message: err && err.message,
+                stack: err && err.stack,
+                status: err && err.xhr && err.xhr.status,
+              },
+            })
+          );
+        }
+      );
+    }
+  });
+}