@inboxsdk/core 0.2.28 → 0.2.29-alpha.0

package/src/platform-implementation-js/lib/insert-link-chip-into-body.js

@@ -1,66 +1,51 @@
-/* @flow */
-
-import * as ud from 'ud';
-import type { ComposeViewDriver } from '../driver-interfaces/compose-view-driver';
-import autoHtml from 'auto-html';
-
-var insertLinkChipIntoBody = ud.defn(
-  module,
-  function (
-    composeViewDriver: ComposeViewDriver,
-    options: Object
-  ): HTMLElement {
-    composeViewDriver.focus();
-
-    var chipElement = _getChipElement(options);
-
-    // Gmail compose treats text directly bordering the chipElement weirdly in
-    // regards to cursor movement, so surround the chip with newlines which
-    // makes Gmail act up a little less.
-    var frag = (document: any).createDocumentFragment();
-    frag.appendChild(document.createTextNode('\u200b'));
-    frag.appendChild(chipElement);
-    frag.appendChild(document.createTextNode('\u200b'));
-
-    composeViewDriver.insertBodyHTMLAtCursor(frag);
-
-    if (
-      !composeViewDriver.isFullscreen() &&
-      !composeViewDriver.isInlineReplyForm() &&
-      document.activeElement !== composeViewDriver.getBodyElement()
-    ) {
-      composeViewDriver.setMinimized(true);
-      composeViewDriver.setMinimized(false);
-    }
-
-    composeViewDriver.focus();
-
-    return chipElement;
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var ud = _interopRequireWildcard(require("ud"));
+var _autoHtml = _interopRequireDefault(require("auto-html"));
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+var insertLinkChipIntoBody = ud.defn(module, function (composeViewDriver, options) {
+  composeViewDriver.focus();
+  var chipElement = _getChipElement(options);
+
+  // Gmail compose treats text directly bordering the chipElement weirdly in
+  // regards to cursor movement, so surround the chip with newlines which
+  // makes Gmail act up a little less.
+  var frag = document.createDocumentFragment();
+  frag.appendChild(document.createTextNode('\u200b'));
+  frag.appendChild(chipElement);
+  frag.appendChild(document.createTextNode('\u200b'));
+  composeViewDriver.insertBodyHTMLAtCursor(frag);
+  if (!composeViewDriver.isFullscreen() && !composeViewDriver.isInlineReplyForm() && document.activeElement !== composeViewDriver.getBodyElement()) {
+    composeViewDriver.setMinimized(true);
+    composeViewDriver.setMinimized(false);
   }
-);
-export default insertLinkChipIntoBody;
-
-function _getChipElement(options: Object): HTMLElement {
+  composeViewDriver.focus();
+  return chipElement;
+});
+var _default = insertLinkChipIntoBody;
+exports.default = _default;
+function _getChipElement(options) {
   var chipElement = document.createElement('div');
-
-  var iconHtml: string = options.iconUrl
-    ? autoHtml`
+  var iconHtml = options.iconUrl ? (0, _autoHtml.default)`
 <img style="height:16px; width:16px; vertical-align: bottom; border: none;" height="16px" width="16px" src="${options.iconUrl}">&nbsp;
-`
-    : '';
-  var chipHTML: string = autoHtml`
+` : '';
+  var chipHTML = (0, _autoHtml.default)`
 <div contenteditable="false" class="inboxsdk__compose_linkChip"
 style="width: 396px; height: 18px; max-height: 18px; padding: 5px; color: rgb(34, 34, 34); font-family: arial; font-style: normal; font-weight: bold; font-size: 13px; cursor: default; border: 1px solid rgb(221, 221, 221); line-height: 1; background-color: rgb(245, 245, 245);" hspace="inboxsdk__chip_main">
-  <a href="${
-    options.url
-  }" target="_blank" style=" display:inline-block; max-width: 366px; overflow:hidden; text-overflow:ellipsis; white-space:nowrap; max-height: 1.2em; text-decoration: none; cursor: pointer; padding: 1px 0; border: none; ">
-    ${{ __html: iconHtml }}
-    <span dir="ltr" style="color: rgb(17, 85, 204); text-decoration: none; vertical-align: bottom;">${
-      options.text
-    }</span>
+  <a href="${options.url}" target="_blank" style=" display:inline-block; max-width: 366px; overflow:hidden; text-overflow:ellipsis; white-space:nowrap; max-height: 1.2em; text-decoration: none; cursor: pointer; padding: 1px 0; border: none; ">
+    ${{
+    __html: iconHtml
+  }}
+    <span dir="ltr" style="color: rgb(17, 85, 204); text-decoration: none; vertical-align: bottom;">${options.text}</span>
   </a>
 </div>
 `;
   chipElement.innerHTML = chipHTML;
-  return (chipElement.children[0]: any);
-}
+  return chipElement.children[0];
+}

package/src/platform-implementation-js/lib/is-valid-app-id.d.ts

@@ -1 +1,2 @@
 export default function isValidAppId(appId: string): boolean;
+//# sourceMappingURL=is-valid-app-id.d.ts.map

package/src/platform-implementation-js/lib/is-valid-app-id.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-valid-app-id.d.ts","sourceRoot":"","sources":["../../../../../src/platform-implementation-js/lib/is-valid-app-id.ts"],"names":[],"mappings":"AAoBA,MAAM,CAAC,OAAO,UAAU,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAY3D"}

package/src/platform-implementation-js/lib/is-valid-app-id.js

@@ -0,0 +1,27 @@
+import Sha1 from 'sha.js/sha1';
+function grandfatherHash(x) {
+    const hasher = new Sha1();
+    hasher.update('YlEHtGl72+c' + x);
+    return hasher.digest('hex');
+}
+const whitelist = new Set([
+    'b540a2819e4b26823288046869e5577852178d69',
+    '1e9084cb394369dcdfd43cfcd84d17b78b0903dd',
+    'a9b816b86b6085eb0b80315da6b2297ff30cf7b6',
+    '5140e277522fd95ece3d540c94b97f443bcc3256',
+    'b56a2d6e6f650ed6eae78774d3b1f02d969d8485',
+    'bc6308648a588258f31f8f4b64f7c4652b6fcaac',
+    '4cb8e6bd1aab0b4b05c7f07fbe8332b842009358', // godMode
+]);
+const appIdRegex = /^sdk_(.{5,15})_([0-9a-f]{10})$/;
+export default function isValidAppId(appId) {
+    if (whitelist.has(grandfatherHash(appId)))
+        return true;
+    const m = appIdRegex.exec(appId);
+    if (!m)
+        return false;
+    const name = m[1], hash = m[2];
+    const shasum = new Sha1();
+    shasum.update(name);
+    return shasum.digest('hex').slice(0, 10) === hash;
+}

package/src/platform-implementation-js/lib/is-valid-email.d.ts

@@ -1 +1,2 @@
 export default function isValidEmail(candidate: string | null | void): boolean;
+//# sourceMappingURL=is-valid-email.d.ts.map

package/src/platform-implementation-js/lib/is-valid-email.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-valid-email.d.ts","sourceRoot":"","sources":["../../../../../src/platform-implementation-js/lib/is-valid-email.ts"],"names":[],"mappings":"AASA,MAAM,CAAC,OAAO,UAAU,YAAY,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI,GAAG,OAAO,CAM7E"}

package/src/platform-implementation-js/lib/is-valid-email.js

@@ -0,0 +1,14 @@
+const re = /^([^<>()[\]\\,;:\s"]+|".+")@[^\s<>]+$/;
+// This function is supposed to be pretty forgiving because emails can have
+// almost anything in their From header. This function exists as a sanity check
+// to make sure that we didn't try to read from the wrong DOM element. It
+// passes anything with at least one @ sign that doesn't contain certain
+// symbols. We might want to make it even less strict and allow more symbols if
+// it turns out people are legitimately receiving emails with these in the From
+// or other recipient headers.
+export default function isValidEmail(candidate) {
+    if (candidate == null) {
+        return false;
+    }
+    return re.test(candidate);
+}

package/src/platform-implementation-js/lib/isNotNil.d.ts

@@ -1 +1,2 @@
 export default function isNotNil<TValue>(value: TValue | null | undefined): value is TValue;
+//# sourceMappingURL=isNotNil.d.ts.map

package/src/platform-implementation-js/lib/isNotNil.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isNotNil.d.ts","sourceRoot":"","sources":["../../../../../src/platform-implementation-js/lib/isNotNil.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,OAAO,UAAU,QAAQ,CAAC,MAAM,EACrC,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAC/B,KAAK,IAAI,MAAM,CAEjB"}

package/src/platform-implementation-js/lib/isNotNil.js

@@ -0,0 +1,5 @@
+// Type predicate to avoid opting out of strict type checking in filter operations.
+// Adapted from https://stackoverflow.com/a/46700791
+export default function isNotNil(value) {
+    return value != null;
+}

package/src/platform-implementation-js/lib/isStreakAppId.d.ts

@@ -1 +1,2 @@
 export default function isStreakAppId(appId: string): boolean;
+//# sourceMappingURL=isStreakAppId.d.ts.map

package/src/platform-implementation-js/lib/isStreakAppId.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isStreakAppId.d.ts","sourceRoot":"","sources":["../../../../../src/platform-implementation-js/lib/isStreakAppId.ts"],"names":[],"mappings":"AAQA,MAAM,CAAC,OAAO,UAAU,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAI5D"}

package/src/platform-implementation-js/lib/isStreakAppId.js

@@ -0,0 +1,11 @@
+import Sha256 from 'sha.js/sha256';
+function hash(x) {
+    const hasher = new Sha256();
+    hasher.update('bdnanNrDjv' + x);
+    return hasher.digest('hex').slice(0, 32);
+}
+export default function isStreakAppId(appId) {
+    // Checks if appId === 'sdk_streak_21e9788951' without putting the appId in
+    // the source. Just using a similar technique to is-valid-app-id.
+    return hash(appId) === 'f471fe7b7343b47a202437c3962cc335';
+}

package/src/platform-implementation-js/lib/logger.d.ts

@@ -26,3 +26,4 @@ export default class Logger {
     }): void;
 }
 export declare function hashEmail(str: string): string;
+//# sourceMappingURL=logger.d.ts.map

package/src/platform-implementation-js/lib/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../../../../src/platform-implementation-js/lib/logger.ts"],"names":[],"mappings":"AAwDA,MAAM,WAAW,SAAS;IACxB,KAAK,CAAC,GAAG,EAAE,KAAK,GAAG,OAAO,EAAE,OAAO,CAAC,EAAE,GAAG,GAAG,IAAI,CAAC;IACjD,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,GAAG,GAAG,IAAI,CAAC;CAC1C;AAED,MAAM,CAAC,OAAO,OAAO,MAAM;IACzB,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,SAAS,CAAU;gBAGzB,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,GAAG,EACT,aAAa,EAAE,MAAM,EACrB,WAAW,EAAE,MAAM;IA8Cd,mBAAmB,CAAC,KAAK,EAAE,MAAM;IAIjC,qBAAqB,IAAI,OAAO;IAOhC,iBAAiB,CAAC,OAAO,EAAE,OAAO;WAI3B,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,CAAC,EAAE,OAAO,CAAC,EAAE,GAAG,GAAG,CAAC;IAS5C,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,CAAC,EAAE,OAAO,CAAC,EAAE,GAAG,GAAG,CAAC;WAS9B,KAAK,CAAC,GAAG,EAAE,KAAK,GAAG,OAAO,EAAE,OAAO,CAAC,EAAE,GAAG;IAIhD,KAAK,CAAC,GAAG,EAAE,KAAK,GAAG,OAAO,EAAE,OAAO,CAAC,EAAE,GAAG;IAIzC,QAAQ,CAAC,GAAG,EAAE,KAAK,GAAG,OAAO,EAAE,OAAO,CAAC,EAAE,GAAG;IAI5C,SAAS,CAAC,GAAG,EAAE,KAAK,GAAG,OAAO,EAAE,OAAO,CAAC,EAAE,GAAG;IAS7C,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,GAAG;IAMpC,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,GAAG;IAU1C,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,GAAG,EAAE,SAAS,CAAC,EAAE,OAAO;IAUhE,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,GAAG;IAQrC,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM;IAapD,YAAY,IAAI,SAAS;IAOzB,wBAAwB,CAC7B,EAAE,EAAE,QAAQ,EACZ,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE;CAqB5B;AA4LD,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAI7C"}

package/src/platform-implementation-js/lib/logger.js

@@ -0,0 +1,441 @@
+/* eslint-disable no-console */
+import Sha256 from 'sha.js/sha256';
+import ajax from '../../common/ajax';
+import getExtensionId from '../../common/get-extension-id';
+import getSessionId from '../../common/get-session-id';
+import logError from '../../common/log-error';
+import PersistentQueue from './persistent-queue';
+import makeMutationObserverStream from './dom/make-mutation-observer-stream';
+import { getXMLHttpRequest } from 'ext-corb-workaround';
+import isStreakAppId from './isStreakAppId';
+// Yeah, this module is a singleton with some shared state. This is just for
+// logging convenience. Other modules should avoid doing this!
+const _extensionAppIds = [];
+let _extensionLoaderVersion;
+let _extensionImplVersion;
+let _extensionUserEmailHash;
+let _extensionUseEventTracking = false;
+let _isUsingSyncAPI = undefined;
+const _sessionId = getSessionId();
+const _loggedDeprecatedMessages = new Set();
+// The logger master is the first InboxSDK extension to load. This
+// first extension is tasked with reporting tracked events to the server.
+const _extensionIsLoggerMaster = (function () {
+    if (typeof document === 'undefined') {
+        return true; // for unit tests
+    }
+    if (document.documentElement.hasAttribute('data-inboxsdk-master-claimed')) {
+        return false;
+    }
+    else {
+        document.documentElement.setAttribute('data-inboxsdk-master-claimed', 'true');
+        return true;
+    }
+})();
+function getAllAppIds() {
+    const str = (typeof document !== 'undefined' &&
+        document.documentElement.getAttribute('data-inboxsdk-active-app-ids')) ||
+        '[]';
+    return JSON.parse(str);
+}
+const _trackedEventsQueue = new PersistentQueue('events');
+const FIRST_LOADED_TIME = Date.now();
+export default class Logger {
+    _appId;
+    _isMaster;
+    constructor(appId, opts, loaderVersion, implVersion) {
+        _extensionLoggerSetup(appId, opts, loaderVersion, implVersion);
+        this._appId = appId;
+        this._isMaster = (() => {
+            if (!_extensionUseEventTracking ||
+                (typeof document !== 'undefined' &&
+                    document.documentElement.hasAttribute('data-inboxsdk-app-logger-master-chosen'))) {
+                return false;
+            }
+            else {
+                document.documentElement.setAttribute('data-inboxsdk-app-logger-master-chosen', 'true');
+                return true;
+            }
+        })();
+        if (this._isMaster && typeof document !== 'undefined') {
+            document.addEventListener('inboxSDKinjectedError', (event) => {
+                if (!(event instanceof CustomEvent && event?.detail)) {
+                    this.error(new Error('Invalid inboxSDKinjectedError event'), event);
+                    return;
+                }
+                const detail = event.detail;
+                this.error(Object.assign(new Error(detail.message), { stack: detail.stack }), detail.details);
+            });
+            document.addEventListener('inboxSDKinjectedEventSdkPassive', (event) => {
+                const detail = event.detail;
+                this.eventSdkPassive(detail.name, detail.details, detail.sensitive);
+            });
+        }
+    }
+    setUserEmailAddress(email) {
+        _extensionUserEmailHash = hashEmail(email);
+    }
+    shouldTrackEverything() {
+        return (_extensionUserEmailHash ===
+            'ca05afe92819df590a4196c31814fdb24050e8f49d8a41613f3d6cfb5729c785');
+    }
+    setIsUsingSyncAPI(isUsing) {
+        _isUsingSyncAPI = isUsing;
+    }
+    static run(cb, details) {
+        try {
+            return cb();
+        }
+        catch (err) {
+            Logger.error(err, details);
+            throw err;
+        }
+    }
+    run(cb, details) {
+        try {
+            return cb();
+        }
+        catch (err) {
+            this.error(err, details);
+            throw err;
+        }
+    }
+    static error(err, details) {
+        _logError(err, details, undefined, false);
+    }
+    error(err, details) {
+        _logError(err, details, this._appId, false);
+    }
+    errorApp(err, details) {
+        _logError(err, details, this._appId, true);
+    }
+    errorSite(err, details) {
+        // Only the first logger instance reports Site errors.
+        if (!this._isMaster) {
+            return;
+        }
+        this.error(err, details);
+    }
+    // Should only be used by the InboxSDK users for their own app events.
+    eventApp(name, details) {
+        _trackEvent(this._appId, 'app', name, details);
+    }
+    // For tracking app events that are possibly triggered by the user. Extensions
+    // can opt out of this with a flag passed to InboxSDK.load().
+    eventSdkActive(name, details) {
+        if (!_extensionUseEventTracking) {
+            return;
+        }
+        _trackEvent(this._appId, 'sdkActive', name, details);
+    }
+    // Track events unrelated to user activity about how the app uses the SDK.
+    // Examples include the app being initialized, and calls to any of the
+    // register___ViewHandler functions.
+    eventSdkPassive(name, details, sensitive) {
+        if (sensitive && !isStreakAppId(this._appId)) {
+            // do not log events if they were marked as sensitive
+            return;
+        }
+        _trackEvent(this._appId, 'sdkPassive', name, details);
+    }
+    // Track Site events.
+    eventSite(name, details) {
+        // Only the first logger instance reports Site events.
+        if (!this._isMaster) {
+            return;
+        }
+        _trackEvent(this._appId, 'gmail', name, details);
+    }
+    deprecationWarning(name, suggestion) {
+        console.warn(`InboxSDK: ${name} is deprecated.` +
+            (suggestion ? ` Please use ${suggestion} instead.` : ''));
+        const key = name + (suggestion ? ':' + suggestion : '');
+        if (!_loggedDeprecatedMessages.has(key)) {
+            this.eventSdkPassive(`deprecated.${name}`);
+            _loggedDeprecatedMessages.add(key);
+        }
+    }
+    getAppLogger() {
+        return {
+            error: (err, details) => this.errorApp(err, details),
+            event: (name, details) => this.eventApp(name, details),
+        };
+    }
+    trackFunctionPerformance(fn, sampleRate, details) {
+        if (Math.random() < sampleRate &&
+            document.visibilityState === 'visible' &&
+            this._isMaster) {
+            const start = Date.now();
+            fn();
+            setTimeout(() => {
+                const now = Date.now();
+                this.eventSdkPassive('function performance result', {
+                    value: now - start,
+                    timeSinceFirstLoad: now - FIRST_LOADED_TIME,
+                    ...details,
+                });
+            }, 10);
+        }
+        else {
+            fn();
+        }
+    }
+}
+function _extensionLoggerSetup(appId, opts, loaderVersion, implVersion) {
+    _extensionAppIds.push(Object.freeze({
+        appId: appId,
+        version: opts.appVersion || undefined,
+    }));
+    document.documentElement.setAttribute('data-inboxsdk-active-app-ids', JSON.stringify(getAllAppIds().concat([
+        {
+            appId: appId,
+            version: opts.appVersion || undefined,
+        },
+    ])));
+    if (_extensionLoaderVersion) {
+        return;
+    }
+    _extensionLoaderVersion = loaderVersion;
+    _extensionImplVersion = implVersion;
+    _extensionUseEventTracking = opts.eventTracking;
+    if (opts.globalErrorLogging) {
+        if (Error.stackTraceLimit < 40) {
+            Error.stackTraceLimit = 40;
+        }
+        window.addEventListener('error', function (event) {
+            // Ugh, currently Chrome makes this pretty useless. Once Chrome fixes
+            // this, we can remove the logged function wrappers around setTimeout and
+            // things.
+            if (event.error) {
+                Logger.error(event.error, 'Uncaught exception');
+            }
+        });
+        replaceFunction(window, 'setTimeout', function (original) {
+            return function wrappedSetTimeout(...args) {
+                if (typeof args[0] == 'function') {
+                    args[0] = makeLoggedFunction(args[0], 'setTimeout callback');
+                }
+                return original.apply(this, args);
+            };
+        });
+        replaceFunction(window, 'setInterval', function (original) {
+            return function wrappedSetInterval(...args) {
+                if (typeof args[0] == 'function') {
+                    args[0] = makeLoggedFunction(args[0], 'setInterval callback');
+                }
+                return original.apply(this, args);
+            };
+        });
+        const ETp = (window.EventTarget && window.EventTarget.prototype) ||
+            window.Node.prototype;
+        replaceFunction(ETp, 'addEventListener', function (original) {
+            return function wrappedAddEventListener(...args) {
+                if (typeof args[1] == 'function') {
+                    try {
+                        // If we've made a logger for this function before, use it again,
+                        // otherwise attach it as a property to the original function.
+                        // This is necessary so that removeEventListener is called with
+                        // the right function.
+                        let loggedFn = args[1].__inboxsdk_logged;
+                        if (!loggedFn) {
+                            loggedFn = makeLoggedFunction(args[1], 'event listener');
+                            // eslint-disable-next-line
+                            args[1].__inboxsdk_logged = loggedFn;
+                        }
+                        args[1] = loggedFn;
+                    }
+                    catch (e) {
+                        // This could be triggered if the given function was immutable
+                        // and stopped us from saving the logged copy on it.
+                        console.error('Failed to error wrap function', e);
+                    }
+                }
+                return original.apply(this, args);
+            };
+        });
+        replaceFunction(ETp, 'removeEventListener', function (original) {
+            return function wrappedRemoveEventListener(...args) {
+                if (typeof args[1] == 'function' && args[1].__inboxsdk_logged) {
+                    args[1] = args[1].__inboxsdk_logged;
+                }
+                return original.apply(this, args);
+            };
+        });
+        replaceFunction(window, 'MutationObserver', function (Original) {
+            Original = Original || window.WebKitMutationObserver;
+            function WrappedMutationObserver(...args) {
+                if (typeof args[0] == 'function') {
+                    args[0] = makeLoggedFunction(args[0], 'MutationObserver callback');
+                }
+                if (Original.bind && Original.bind.apply) {
+                    // call constructor with variable number of arguments
+                    return new (Original.bind.apply(Original, [null].concat(args)))();
+                }
+                else {
+                    // Safari's MutationObserver lacks a bind method, but its constructor
+                    // doesn't support extra arguments anyway, so don't bother logging an
+                    // error here.
+                    return new Original(args[0]);
+                }
+            }
+            // Just in case someone wants to monkey-patch the prototype.
+            WrappedMutationObserver.prototype = Original.prototype;
+            return WrappedMutationObserver;
+        });
+    }
+}
+function getAppIdsProperty(causedByAppId, onlyExtensionApps = true) {
+    const appIds = onlyExtensionApps ? _extensionAppIds : getAllAppIds();
+    if (!causedByAppId) {
+        return appIds;
+    }
+    else {
+        const appIdsWithCause = appIds.slice();
+        let hasSetCause = false;
+        appIdsWithCause.forEach((entry, i) => {
+            if (!hasSetCause && entry.appId === causedByAppId) {
+                hasSetCause = true;
+                appIdsWithCause[i] = { ...entry, causedBy: true };
+            }
+            Object.freeze(appIdsWithCause[i]);
+        });
+        return Object.freeze(appIdsWithCause);
+    }
+}
+// err should be an Error instance, and details can be any JSON-ifiable value.
+function _logError(err, details, appId, sentByApp) {
+    logError(err, details, {
+        appId,
+        sentByApp,
+        appIds: getAppIdsProperty(appId),
+        loaderVersion: _extensionLoaderVersion,
+        implVersion: _extensionImplVersion,
+        userEmailHash: _extensionUserEmailHash,
+        isUsingSyncAPI: _isUsingSyncAPI,
+    });
+}
+function makeLoggedFunction(func, name) {
+    const msg = name ? 'Uncaught error in ' + name : 'Uncaught error';
+    return function (...args) {
+        return Logger.run(() => func.apply(this, args), msg);
+    };
+}
+function replaceFunction(parent, name, newFnMaker) {
+    const newFn = newFnMaker(parent[name]);
+    newFn.__original = parent[name];
+    parent[name] = newFn;
+}
+export function hashEmail(str) {
+    const hasher = new Sha256();
+    hasher.update('inboxsdk:' + str);
+    return hasher.digest('hex');
+}
+function _trackEvent(appId, type, eventName, properties) {
+    if (properties && typeof properties != 'object') {
+        throw new Error('properties must be object or null: ' + properties);
+    }
+    const event = {
+        type: type,
+        event: eventName,
+        timestamp: Date.now() * 1000,
+        origin: document.location.origin,
+        sessionId: _sessionId,
+        emailHash: _extensionUserEmailHash,
+        loaderVersion: _extensionLoaderVersion,
+        implementationVersion: _extensionImplVersion,
+        isUsingSyncAPI: _isUsingSyncAPI,
+        properties: properties,
+    };
+    if (type != 'gmail') {
+        Object.assign(event, {
+            extensionId: getExtensionId(),
+            appIds: getAppIdsProperty(appId),
+        });
+    }
+    else {
+        Object.assign(event, {
+            appIds: getAppIdsProperty(null, false),
+        });
+    }
+    if (typeof document === 'undefined') {
+        return;
+    }
+    _trackedEventsQueue.add(event);
+    // Signal to the logger master that a new event is ready to be sent.
+    document.documentElement.setAttribute('data-inboxsdk-last-event', '' + Date.now());
+}
+let currentAccessToken = null;
+function isTimestampExpired(n) {
+    // Let's refresh the token 10 minutes early
+    return Date.now() + 10 * 60 * 1000 > n;
+}
+async function retrieveNewEventsAccessToken() {
+    const { text } = await ajax({
+        url: 'https://api.inboxsdk.com/api/v2/events/oauth',
+        // Work around CORB for extensions that have permissions to inboxsdk.com
+        XMLHttpRequest: getXMLHttpRequest(),
+    });
+    const accessToken = JSON.parse(text);
+    if (isTimestampExpired(accessToken.expirationDate)) {
+        console.warn('Got an apparently already expired token. Assuming our clock is busted...');
+        // Let's assume the token expires in 30 minutes. The server refreshes the
+        // token 30 minutes before it expires so it's probably a safe bet.
+        accessToken.expirationDate = Date.now() + 30 * 60 * 1000;
+    }
+    return accessToken;
+}
+async function getEventsAccessToken() {
+    const t = currentAccessToken;
+    if (t && !isTimestampExpired(t.expirationDate)) {
+        return t;
+    }
+    else {
+        currentAccessToken = await retrieveNewEventsAccessToken();
+        return currentAccessToken;
+    }
+}
+if (_extensionIsLoggerMaster &&
+    typeof document !== 'undefined' &&
+    typeof MutationObserver !== 'undefined') {
+    makeMutationObserverStream(document.documentElement, {
+        attributes: true,
+        attributeFilter: ['data-inboxsdk-last-event'],
+    })
+        .map(() => null)
+        .throttle(120 * 1000)
+        .onValue(function () {
+        const events = _trackedEventsQueue.removeAll();
+        // The trackedEventsQueue is in localStorage, which is shared between
+        // multiple tabs. A different tab could have flushed it already recently.
+        if (events.length === 0) {
+            return;
+        }
+        (async function () {
+            const { oauthToken } = await getEventsAccessToken();
+            const apiKey = 'AIzaSyAwlvUR2x3OnCeas8hW8NDzVMswL5hZGg8';
+            // TODO change to use CommonPageCommunicator.pageAjax()
+            await ajax({
+                url: `https://pubsub.googleapis.com/v1/projects/mailfoogae/topics/events:publish?key=${encodeURIComponent(apiKey)}`,
+                method: 'POST',
+                headers: {
+                    Authorization: `Bearer ${oauthToken}`,
+                    'Content-Type': 'application/json',
+                },
+                data: JSON.stringify({
+                    messages: [
+                        {
+                            data: Buffer.from(JSON.stringify({
+                                data: events,
+                                timestamp: Date.now() * 1000,
+                            })).toString('base64'),
+                        },
+                    ],
+                }),
+            });
+        })().catch((err) => {
+            Logger.error(err, {
+                type: 'Failed to log events',
+            });
+        });
+    });
+}