@inboxsdk/core 0.2.28-alpha.2 → 0.2.28-alpha.4

package/src/platform-implementation-js/dom-driver/gmail/widgets/gmail-dropdown-view.js

@@ -0,0 +1,22 @@
+import blockAndReemiteKeyboardEvents from '../../../lib/dom/block-and-reemit-keyboard-events';
+export default class GmailDropdownView {
+    _containerElement;
+    _contentElement;
+    constructor() {
+        this._containerElement = document.createElement('div');
+        this._containerElement.setAttribute('class', 'inboxsdk__menu');
+        this._contentElement = document.createElement('div');
+        this._contentElement.setAttribute('class', 'inboxsdk__menuContent');
+        this._containerElement.appendChild(this._contentElement);
+        blockAndReemiteKeyboardEvents(this._containerElement);
+    }
+    destroy() {
+        this._containerElement.remove();
+    }
+    getContainerElement() {
+        return this._containerElement;
+    }
+    getContentElement() {
+        return this._contentElement;
+    }
+}

package/src/platform-implementation-js/driver-common/getAccountUrlPart.js

@@ -0,0 +1,17 @@
+/*
+ returns "/u/NUMBER" or "/u/NUMBER/d/DELEGATE_ID" for delegated accounts
+*/
+export default function getAccountUrlPart() {
+    const delegatedAccountMatch = document.location.pathname.match(/\/b\/(.+?)\/u\/(\d+)/);
+    if (delegatedAccountMatch) {
+        const delegatedAccountId = delegatedAccountMatch[1];
+        const delegatedAccountNumber = delegatedAccountMatch[2];
+        return `/u/${delegatedAccountNumber}/d/${delegatedAccountId}`;
+    }
+    else {
+        const accountParamMatch = document.location.pathname.match(/(\/u\/\d+)\//i);
+        //no match happens in inbox when user only has one account
+        const accountParam = accountParamMatch ? accountParamMatch[1] : '/u/0';
+        return accountParam;
+    }
+}

package/src/platform-implementation-js/driver-common/getOriginalMessagePage.js

@@ -0,0 +1,33 @@
+import { defn } from 'ud';
+import gmailAjax from './gmailAjax';
+async function getOriginalMessagePage(driver, options) {
+    const data = {
+        ik: driver.getPageCommunicator().getIkValue(),
+        view: 'om',
+    };
+    if (options.oldGmailMessageID) {
+        data.th = options.oldGmailMessageID;
+    }
+    else if (options.syncMessageID) {
+        data.permmsgid = options.syncMessageID;
+    }
+    let url;
+    const delegatedAccountMatch = document.location.pathname.match(/\/b\/(.+?)\/u\/(\d+)/);
+    if (delegatedAccountMatch) {
+        url = document.location.origin + document.location.pathname;
+    }
+    else {
+        const accountParamMatch = document.location.pathname.match(/(\/u\/\d+)\//i);
+        //no match happens in inbox when user only has one account
+        const accountParam = accountParamMatch ? accountParamMatch[1] : '/u/0';
+        url = `https://mail.google.com/mail${accountParam}`;
+    }
+    const { text } = await gmailAjax({
+        url,
+        method: 'GET',
+        canRetry: true,
+        data,
+    });
+    return text;
+}
+export default defn(module, getOriginalMessagePage);

package/src/platform-implementation-js/driver-common/getSyncThreadsForSearch.js

@@ -0,0 +1,49 @@
+import { defn } from 'ud';
+import { extractThreadsFromSearchResponse } from '../dom-driver/gmail/gmail-sync-response-processor';
+import gmailAjax from './gmailAjax';
+import getAccountUrlPart from './getAccountUrlPart';
+async function getSyncThreadsForSearch(driver, searchTerm) {
+    let responseText = null;
+    try {
+        const { text } = await gmailAjax({
+            method: 'POST',
+            url: `https://mail.google.com/sync${getAccountUrlPart()}/i/bv`,
+            headers: {
+                'Content-Type': 'application/json',
+                'X-Framework-Xsrf-Token': await driver
+                    .getPageCommunicator()
+                    .getXsrfToken(),
+                'X-Gmail-BTAI': await driver.getPageCommunicator().getBtaiHeader(),
+                'X-Google-BTD': '1',
+            },
+            data: JSON.stringify({
+                '1': {
+                    '2': 1,
+                    '4': searchTerm,
+                },
+            }),
+        });
+        responseText = text;
+    }
+    catch (err) {
+        const { text } = await gmailAjax({
+            method: 'POST',
+            url: `https://mail.google.com/sync${getAccountUrlPart()}/i/bv?rt=r&pt=ji`,
+            headers: {
+                'Content-Type': 'application/json',
+                'X-Framework-Xsrf-Token': await driver
+                    .getPageCommunicator()
+                    .getXsrfToken(),
+                'X-Gmail-BTAI': await driver.getPageCommunicator().getBtaiHeader(),
+                'X-Google-BTD': '1',
+            },
+            data: JSON.stringify([[null, 51, null, searchTerm]]),
+        });
+        responseText = text;
+    }
+    return {
+        threads: extractThreadsFromSearchResponse(responseText),
+        _text: responseText,
+    };
+}
+export default defn(module, getSyncThreadsForSearch);

package/src/platform-implementation-js/driver-common/gmailAjax.js

@@ -0,0 +1,65 @@
+import { defn } from 'ud';
+import Kefir from 'kefir';
+import imageRequest from '../lib/imageRequest';
+import rateLimitQueuer from '../../common/rate-limit-queuer';
+import ajax from '../../common/ajax';
+const IMAGE_REQUEST_TIMEOUT = 1000 * 60; // one minute
+const limitedAjax = rateLimitQueuer(rateLimitQueuer(ajax, 1000, 7), 10 * 1000, 50);
+// Tool for making ajax requests to Gmail endpoints. When used in Inbox, this
+// function is able to handle the issue that happens when the user has no Gmail
+// cookies.
+async function gmailAjax(opts) {
+    if (!/^https:\/\/mail\.google\.com(?:$|\/)/.test(opts.url)) {
+        throw new Error('Should not happen: gmailAjax called with non-gmail url');
+    }
+    if (document.location.origin === 'https://mail.google.com') {
+        return await limitedAjax(opts);
+    }
+    try {
+        return await limitedAjax({ ...opts, canRetry: false });
+    }
+    catch (e) {
+        if (e && e.status === 0) {
+            // The connection failed for an unspecified reason. One possible reason
+            // is that we have no Gmail cookies, and the connection tried to redirect
+            // to an accounts.google.com URL so the Gmail cookies could be set, but
+            // then this connection failed because we don't have ajax permission to
+            // accounts.google.com. We can work around this by trying an image
+            // request (which doesn't have cross-domain restrictions) so the Gmail
+            // cookies get set, and then retrying the original ajax request.
+            try {
+                await Kefir.fromPromise(imageRequest('https://mail.google.com/mail/u/0/'))
+                    .merge(Kefir.later(IMAGE_REQUEST_TIMEOUT, undefined))
+                    .take(1)
+                    .takeErrors(1)
+                    .toPromise();
+            }
+            catch (e) {
+                // ignore. If we got an error here, there are several possible causes:
+                // 1. The user has Gmail cookies, but the first connection attempt
+                //    failed for another reason. In this case, we don't care about how
+                //    this image request turned out.
+                // 2. The user did not have Gmail cookies, and the image's original
+                //    request and its first few redirects succeeded, setting the
+                //    cookies, but the final request, after the cookies were set,
+                //    failed. We don't care about the image's final request.
+                // 3. The user did not have Gmail cookies, and the image request didn't
+                //    work at all.
+                // In the final case, ideally we would retry the image request, but we
+                // can't distinguish that case from the other cases and doing retries
+                // of the image request would slow down the other cases. The first case
+                // is expected to be significantly more common -- the second two cases
+                // where the user has no Gmail cookies is expected to happen maybe once
+                // in total to an individual user.
+            }
+            return await limitedAjax(opts);
+        }
+        else if (e && typeof e.status === 'number' && e.status >= 500) {
+            return await limitedAjax(opts);
+        }
+        else {
+            throw e;
+        }
+    }
+}
+export default defn(module, gmailAjax);

package/src/platform-implementation-js/driver-common/render-custom-icon.js

@@ -0,0 +1,16 @@
+export default function renderCustomIcon(containerElement, customIconElement, append, insertBeforeEl) {
+    // Check if icon wrapper exist or not
+    // when renderCustomIcon gets called for updating navItemDescriptor
+    let iconElementWrapper = containerElement.querySelector('.inboxsdk__button_icon');
+    if (!iconElementWrapper) {
+        iconElementWrapper = document.createElement('div');
+        iconElementWrapper.classList.add('inboxsdk__button_icon');
+        iconElementWrapper.appendChild(customIconElement);
+    }
+    if (append) {
+        containerElement.appendChild(iconElementWrapper);
+    }
+    else {
+        containerElement.insertBefore(containerElement, insertBeforeEl || containerElement.firstElementChild);
+    }
+}

package/src/platform-implementation-js/driver-common/update-icon.js

@@ -0,0 +1,90 @@
+function createIconElement(containerElement, append, insertBeforeEl) {
+    const iconElement = document.createElement('div');
+    iconElement.classList.add('inboxsdk__button_icon');
+    iconElement.innerHTML = ' ';
+    if (append) {
+        containerElement.appendChild(iconElement);
+    }
+    else {
+        containerElement.insertBefore(iconElement, insertBeforeEl || containerElement.firstElementChild);
+    }
+    return iconElement;
+}
+function createIconImgElement(iconUrl, containerElement, append, insertBeforeEl) {
+    const iconElement = createIconElement(containerElement, append, insertBeforeEl);
+    iconElement.innerHTML = '';
+    const iconImgElement = document.createElement('img');
+    iconImgElement.classList.add('inboxsdk__button_iconImg');
+    iconImgElement.src = iconUrl;
+    iconElement.appendChild(iconImgElement);
+    return iconElement;
+}
+// TODO make this return a class instead of taking the iconSettings state object
+export default function updateIcon(iconSettings, containerElement, append, newIconClass, newIconUrl, insertBeforeEl, // Should not be used with append: true — the append flag will override
+newIconHtml) {
+    if (append && insertBeforeEl)
+        throw new Error('append and insertBeforeEl should not be used together');
+    // if iconHtml exists, class or url presents just throw error
+    if (newIconHtml && (newIconClass || newIconUrl)) {
+        throw new Error('iconHtml can not be used together with iconClass or iconUrl');
+    }
+    if (newIconHtml) {
+        if (!iconSettings.iconHtmlElement) {
+            iconSettings.iconHtmlElement = createIconElement(containerElement, append, insertBeforeEl);
+        }
+        iconSettings.iconHtmlElement.innerHTML = newIconHtml;
+        if (iconSettings.iconImgElement) {
+            iconSettings.iconImgElement.remove();
+            iconSettings.iconImgElement = null;
+        }
+        if (iconSettings.iconElement) {
+            iconSettings.iconElement.remove();
+            iconSettings.iconElement = null;
+        }
+    }
+    else if (newIconUrl) {
+        if (!iconSettings.iconImgElement) {
+            iconSettings.iconImgElement = createIconImgElement(newIconUrl, containerElement, append, insertBeforeEl);
+        }
+        else {
+            iconSettings.iconImgElement.firstElementChild.src = newIconUrl;
+        }
+        iconSettings.iconImgElement.setAttribute('class', `inboxsdk__button_icon ${newIconClass || ''}`);
+        if (iconSettings.iconHtmlElement) {
+            iconSettings.iconHtmlElement.remove();
+            iconSettings.iconHtmlElement = null;
+        }
+        if (iconSettings.iconElement) {
+            iconSettings.iconElement.remove();
+            iconSettings.iconElement = null;
+        }
+    }
+    else if (newIconClass) {
+        if (!iconSettings.iconElement) {
+            iconSettings.iconElement = createIconElement(containerElement, append, insertBeforeEl);
+        }
+        iconSettings.iconElement.setAttribute('class', 'inboxsdk__button_icon ' + newIconClass);
+        if (iconSettings.iconHtmlElement) {
+            iconSettings.iconHtmlElement.remove();
+            iconSettings.iconHtmlElement = null;
+        }
+        if (iconSettings.iconImgElement) {
+            iconSettings.iconImgElement.remove();
+            iconSettings.iconImgElement = null;
+        }
+    }
+    else {
+        if (iconSettings.iconElement) {
+            iconSettings.iconElement.remove();
+            iconSettings.iconElement = null;
+        }
+        if (iconSettings.iconHtmlElement) {
+            iconSettings.iconHtmlElement.remove();
+            iconSettings.iconHtmlElement = null;
+        }
+        if (iconSettings.iconImgElement) {
+            iconSettings.iconImgElement.remove();
+            iconSettings.iconImgElement = null;
+        }
+    }
+}

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

@@ -0,0 +1,47 @@
+import Logger from './logger';
+export default class ErrorCollector {
+    _name;
+    _runCount = 0;
+    _errorLogs = [];
+    _hasReported = false;
+    constructor(name) {
+        this._name = name;
+    }
+    run(name, cb) {
+        if (this._hasReported) {
+            throw new Error('Has already reported');
+        }
+        this._runCount++;
+        try {
+            return cb();
+        }
+        catch (e) {
+            this._errorLogs.push({
+                name,
+                message: e.message,
+            });
+            return null;
+        }
+    }
+    report(errorDataCb) {
+        if (this._hasReported) {
+            throw new Error('Has already reported');
+        }
+        this._hasReported = true;
+        if (this._errorLogs.length) {
+            Logger.error(new Error(`Error Collector: ${this._name}`), {
+                errorLogs: this._errorLogs,
+                extra: errorDataCb(),
+            });
+        }
+    }
+    getErrorLogs() {
+        return this._errorLogs;
+    }
+    runCount() {
+        return this._runCount;
+    }
+    errorCount() {
+        return this._errorLogs.length;
+    }
+}

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

@@ -0,0 +1,22 @@
+// Used to make the *View objects out of our *ViewDriver objects, and to make
+// sure we return the same *View object back if we've already made one for
+// given *ViewDriver.
+export default class Membrane {
+    _mappers;
+    _map = new WeakMap();
+    constructor(mappers) {
+        this._mappers = new Map(mappers);
+    }
+    get(wet) {
+        let dry = this._map.get(wet);
+        if (!dry) {
+            const mapperFn = this._mappers.get(wet.constructor);
+            if (!mapperFn) {
+                throw new Error(`Unknown class ${wet.constructor.name}`);
+            }
+            dry = mapperFn(wet);
+            this._map.set(wet, dry);
+        }
+        return dry;
+    }
+}

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

@@ -0,0 +1,30 @@
+import containByScreen from 'contain-by-screen';
+import Kefir from 'kefir';
+import kefirBus from 'kefir-bus';
+import kefirStopper from 'kefir-stopper';
+import fromEventsWithOptions from './fromEventsWithOptions';
+export default class ScrollableContainByScreen {
+    _manualRepositions = kefirBus();
+    _stopper = kefirStopper();
+    constructor(element, anchorPoint, options) {
+        Kefir.merge([
+            this._manualRepositions,
+            Kefir.fromEvents(window, 'resize'),
+            fromEventsWithOptions(window, 'scroll', {
+                capture: true,
+                passive: true,
+            }).filter((event) => event.target.contains(anchorPoint)),
+        ])
+            .toProperty(() => null)
+            .takeUntilBy(this._stopper)
+            .onValue(() => {
+            containByScreen(element, anchorPoint, options);
+        });
+    }
+    reposition() {
+        this._manualRepositions.emit(null);
+    }
+    destroy() {
+        this._stopper.destroy();
+    }
+}

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

@@ -0,0 +1,16 @@
+export default async function attemptWithRetries(fn, attemptCount, errorsToRetry = () => true) {
+    if (attemptCount < 1) {
+        throw new Error('Attempt count must be positive');
+    }
+    try {
+        return await fn();
+    }
+    catch (err) {
+        if (attemptCount > 1 && errorsToRetry(err)) {
+            return attemptWithRetries(fn, attemptCount - 1, errorsToRetry);
+        }
+        else {
+            throw err;
+        }
+    }
+}

package/src/platform-implementation-js/lib/common-page-communicator.js

@@ -0,0 +1,137 @@
+import asap from 'asap';
+import once from 'lodash/once';
+import * as Kefir from 'kefir';
+import Logger from './logger';
+export default class CommonPageCommunicator {
+    ajaxInterceptStream;
+    constructor() {
+        this.ajaxInterceptStream = Kefir.fromEvents(document, 'inboxSDKajaxIntercept').map((x) => x.detail);
+    }
+    getUserEmailAddress() {
+        const s = document.head.getAttribute('data-inboxsdk-user-email-address');
+        if (typeof s !== 'string')
+            throw new Error('should not happen');
+        return s;
+    }
+    getUserLanguage() {
+        const s = document.head.getAttribute('data-inboxsdk-user-language');
+        if (typeof s !== 'string')
+            throw new Error('should not happen');
+        return s;
+    }
+    getIkValue() {
+        const ownIk = document.head.getAttribute('data-inboxsdk-ik-value');
+        if (ownIk) {
+            return ownIk;
+        }
+        // For standalone windows.
+        if (window.opener) {
+            const openerIk = window.opener.document.head.getAttribute('data-inboxsdk-ik-value');
+            if (openerIk) {
+                return openerIk;
+            }
+            else {
+                throw new Error("Failed to look up parent window 'ik' value");
+            }
+        }
+        throw new Error("Failed to look up 'ik' value");
+    }
+    isUsingSyncAPI() {
+        return false;
+    }
+    async getXsrfToken() {
+        const existingHeader = document.head.getAttribute('data-inboxsdk-xsrf-token');
+        if (existingHeader) {
+            return existingHeader;
+        }
+        else {
+            await this.ajaxInterceptStream
+                .filter(({ type }) => type === 'xsrfTokenHeaderReceived')
+                .take(1)
+                .toPromise();
+            const newHeader = document.head.getAttribute('data-inboxsdk-xsrf-token');
+            if (!newHeader)
+                throw new Error('Failed to look up XSRF token');
+            return newHeader;
+        }
+    }
+    async getBtaiHeader() {
+        const existingHeader = document.head.getAttribute('data-inboxsdk-btai-header');
+        if (existingHeader) {
+            return existingHeader;
+        }
+        else {
+            await this.ajaxInterceptStream
+                .filter(({ type }) => type === 'btaiHeaderReceived')
+                .take(1)
+                .toPromise();
+            const newHeader = document.head.getAttribute('data-inboxsdk-btai-header');
+            if (!newHeader)
+                throw new Error('Failed to look up BTAI header');
+            return newHeader;
+        }
+    }
+    resolveUrlRedirects(url) {
+        return this.pageAjax({ url, method: 'HEAD' }).then((result) => result.responseURL);
+    }
+    pageAjax(opts) {
+        const id = `${Date.now()}-${Math.random()}`;
+        const promise = Kefir.fromEvents(document, 'inboxSDKpageAjaxDone')
+            .filter((event) => event.detail && event.detail.id === id)
+            .take(1)
+            .flatMap((event) => {
+            if (event.detail.error) {
+                const err = Object.assign(new Error(event.detail.message || 'Connection error'), { status: event.detail.status });
+                if (event.detail.stack) {
+                    err.stack = event.detail.stack;
+                }
+                return Kefir.constantError(err);
+            }
+            else {
+                return Kefir.constant({
+                    text: event.detail.text,
+                    responseURL: event.detail.responseURL,
+                });
+            }
+        })
+            .toPromise();
+        document.dispatchEvent(new CustomEvent('inboxSDKpageAjax', {
+            bubbles: false,
+            cancelable: false,
+            detail: Object.assign({}, opts, { id }),
+        }));
+        return promise;
+    }
+    silenceGmailErrorsForAMoment() {
+        document.dispatchEvent(new CustomEvent('inboxSDKsilencePageErrors', {
+            bubbles: false,
+            cancelable: false,
+            detail: null,
+        }));
+        // create error here for stacktrace
+        const error = new Error('Forgot to unsilence page errors');
+        let unsilenced = false;
+        const unsilence = once(() => {
+            unsilenced = true;
+            document.dispatchEvent(new CustomEvent('inboxSDKunsilencePageErrors', {
+                bubbles: false,
+                cancelable: false,
+                detail: null,
+            }));
+        });
+        asap(() => {
+            if (!unsilenced) {
+                Logger.error(error);
+                unsilence();
+            }
+        });
+        return unsilence;
+    }
+    registerAllowedHashLinkStartTerm(term) {
+        document.dispatchEvent(new CustomEvent('inboxSDKregisterAllowedHashLinkStartTerm', {
+            bubbles: false,
+            cancelable: false,
+            detail: { term },
+        }));
+    }
+}

package/src/platform-implementation-js/lib/delay-asap.js

@@ -0,0 +1,12 @@
+import asap from 'asap';
+import * as Kefir from 'kefir';
+// Returns a stream that emits a value in the next event loop run. Works well
+// with flatmap.
+export default function delayAsap(value) {
+    return Kefir.stream((emitter) => {
+        asap(() => {
+            emitter.emit(value);
+            emitter.end();
+        });
+    });
+}

package/src/platform-implementation-js/lib/delay-idle.js

@@ -0,0 +1,16 @@
+import * as Kefir from 'kefir';
+const requestIdleCallback = global.requestIdleCallback || ((cb) => setTimeout(cb, 0));
+const cancelIdleCallback = global.cancelIdleCallback || clearTimeout;
+// Returns a stream that emits a value using requestIdleCallback. Works well
+// with flatmap.
+export default function delayIdle(timeout, value) {
+    return Kefir.stream((emitter) => {
+        const t = requestIdleCallback(() => {
+            emitter.emit(value);
+            emitter.end();
+        }, timeout == null ? null : { timeout });
+        return () => {
+            cancelIdleCallback(t);
+        };
+    });
+}

package/src/platform-implementation-js/lib/dom/block-and-reemit-keyboard-events.js

@@ -0,0 +1,36 @@
+import Kefir from 'kefir';
+export default function blockAndReemiteKeyboardEvents(element) {
+    // Gmail stops propagation of keyboard events from escaping
+    // a specific compose window, which prevents any React components rendered
+    // in the compose window's subtree from getting them (since React adds
+    // a single event listener on the document). By stopping propagation of
+    // the original event and reemiting it on the document, we preserve
+    // exisitng behavior while giving React a chance to hear it.
+    Kefir.merge([
+        Kefir.fromEvents(element, 'keypress'),
+        Kefir.fromEvents(element, 'keydown'),
+        Kefir.fromEvents(element, 'keyup'),
+    ]).onValue((event) => {
+        event.stopPropagation();
+        const fakeEvent = new KeyboardEvent(event.type, { bubbles: true });
+        Object.defineProperties(fakeEvent, {
+            cancelable: { value: event.cancelable },
+            bubbles: { value: event.bubbles },
+            target: { value: event.target },
+            detail: { value: event.detail },
+            key: { value: event.key },
+            code: { value: event.code },
+            location: { value: event.location },
+            ctrlKey: { value: event.ctrlKey },
+            shiftKey: { value: event.shiftKey },
+            altKey: { value: event.altKey },
+            metaKey: { value: event.metaKey },
+            repeat: { value: event.repeat },
+            isComposing: { value: event.isComposing },
+            charCode: { value: event.charCode },
+            keyCode: { value: event.keyCode },
+            which: { value: event.which },
+        });
+        document.dispatchEvent(fakeEvent);
+    });
+}

package/src/platform-implementation-js/lib/dom/generic-button-view.js

@@ -0,0 +1,39 @@
+import * as Kefir from 'kefir';
+import kefirBus from 'kefir-bus';
+export default class GenericButtonView {
+    _eventStream = kefirBus();
+    _element;
+    constructor(element) {
+        this._element = element;
+        this._setupEventStream();
+    }
+    destroy() {
+        this._element.remove();
+        this._eventStream.end();
+    }
+    getElement() {
+        return this._element;
+    }
+    getEventStream() {
+        return this._eventStream;
+    }
+    activate() {
+        /* do nothing */
+    }
+    deactivate() {
+        /* do nothing */
+    }
+    _setupEventStream() {
+        const clickEventStream = Kefir.fromEvents(this._element, 'click');
+        clickEventStream.onValue((event) => {
+            event.stopPropagation();
+            event.preventDefault();
+        });
+        this._eventStream.plug(clickEventStream.map((event) => {
+            return {
+                eventName: 'click',
+                domEvent: event,
+            };
+        }));
+    }
+}