@inboxsdk/core 0.2.28-alpha.3 → 0.2.28-alpha.5

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/copyAndValidateAutocompleteResults.js

@@ -1,55 +1,36 @@
-/* @flow */
+"use strict";
 
-import type { Driver } from '../driver-interfaces/driver';
-import type { AutocompleteSearchResult } from '../../injected-js/gmail/modify-suggestions';
-
-export default function copyAndValidateAutocompleteResults(
-  driver: Driver,
-  results: Array<AutocompleteSearchResult>
-): Array<AutocompleteSearchResult> {
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = copyAndValidateAutocompleteResults;
+function copyAndValidateAutocompleteResults(driver, results) {
   if (!Array.isArray(results)) {
     throw new Error('suggestions must be an array');
   }
-
-  return results.map((result) => {
-    const resultCopy = { ...result };
-    if (
-      typeof resultCopy.name !== 'string' &&
-      typeof resultCopy.nameHTML !== 'string'
-    ) {
+  return results.map(result => {
+    const resultCopy = {
+      ...result
+    };
+    if (typeof resultCopy.name !== 'string' && typeof resultCopy.nameHTML !== 'string') {
       throw new Error('suggestion must have name or nameHTML property');
     }
-    if (
-      typeof resultCopy.routeName !== 'string' &&
-      typeof resultCopy.externalURL !== 'string' &&
-      typeof resultCopy.searchTerm !== 'string' &&
-      typeof resultCopy.onClick !== 'function'
-    ) {
-      throw new Error(
-        'suggestion must have routeName, externalURL, ' +
-          'searchTerm, or onClick property'
-      );
+    if (typeof resultCopy.routeName !== 'string' && typeof resultCopy.externalURL !== 'string' && typeof resultCopy.searchTerm !== 'string' && typeof resultCopy.onClick !== 'function') {
+      throw new Error('suggestion must have routeName, externalURL, ' + 'searchTerm, or onClick property');
     }
-    if (typeof (resultCopy: any).iconURL === 'string') {
-      const iconURL = (resultCopy: any).iconURL;
-      driver
-        .getLogger()
-        .deprecationWarning(
-          'AutocompleteSearchResult "iconURL" property',
-          'AutocompleteSearchResult.iconUrl'
-        );
+    if (typeof resultCopy.iconURL === 'string') {
+      const iconURL = resultCopy.iconURL;
+      driver.getLogger().deprecationWarning('AutocompleteSearchResult "iconURL" property', 'AutocompleteSearchResult.iconUrl');
       if (!resultCopy.iconUrl) {
         if (driver.getOpts().REQUESTED_API_VERSION === 1) {
           resultCopy.iconUrl = iconURL;
         } else {
           // eslint-disable-next-line no-console
-          console.error(
-            'Support for iconURL property was dropped after API version 1'
-          );
+          console.error('Support for iconURL property was dropped after API version 1');
         }
       }
-      delete (resultCopy: any).iconURL;
+      delete resultCopy.iconURL;
     }
     return resultCopy;
   });
-}
+}

package/src/platform-implementation-js/lib/css-selector-escape.js

@@ -1,8 +1,12 @@
-/* @flow */
+"use strict";
 
-export default function cssSelectorEscape(text: string): string {
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = cssSelectorEscape;
+function cssSelectorEscape(text) {
   if (text.length === 0 || /^-?[0-9]/.test(text)) {
     throw new Error('Invalid CSS selector');
   }
   return text.replace(/[^a-z0-9]/g, '\\$&');
-}
+}

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/element-view-mapper.js

@@ -1,20 +1,17 @@
-/* @flow */
-
-import type Kefir from 'kefir';
+"use strict";
 
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = elementViewMapper;
 // Returns a function suitable for mapping over a stream returned from
 // makeElementChildStream or kefirMakeElementChildStream.
-type View = { destroy(): void };
-import type { ElementWithLifetime } from './make-element-child-stream';
-
-export default function elementViewMapper<T: View>(
-  viewFn: (el: HTMLElement) => T
-): (event: ElementWithLifetime) => T {
-  return (event) => {
+function elementViewMapper(viewFn) {
+  return event => {
     const view = viewFn(event.el);
     event.removalStream.take(1).onValue(() => {
       view.destroy();
     });
     return view;
   };
-}
+}

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,
+            };
+        }));
+    }
+}

package/src/platform-implementation-js/lib/dom/get-insert-before-element.js

@@ -0,0 +1,39 @@
+// Use insert-element-in-order instead of this!
+export default function getInsertBeforeElement(checkElement, childElements, dataAttributes) {
+    const checkValues = {};
+    dataAttributes.forEach(function (attribute) {
+        const stringValue = checkElement.getAttribute(attribute);
+        checkValues[attribute] =
+            stringValue == null ? null : parseIfNumber(stringValue) ?? stringValue;
+    });
+    for (let ii = 0; ii < childElements.length; ii++) {
+        const child = childElements[ii];
+        if (_isChildAfter(checkValues, child, dataAttributes)) {
+            return child;
+        }
+    }
+    return null;
+}
+function _isChildAfter(checkValues, child, dataAttributes) {
+    for (let ii = 0; ii < dataAttributes.length; ii++) {
+        const attribute = dataAttributes[ii];
+        const stringValue = child.getAttribute(attribute);
+        const value = stringValue == null ? null : parseIfNumber(stringValue) ?? stringValue;
+        if (value > checkValues[attribute]) {
+            return true;
+        }
+        else if (value < checkValues[attribute]) {
+            return false;
+        }
+    }
+    return false;
+}
+function parseIfNumber(value) {
+    const n = parseFloat(value);
+    if (!isNaN(n) && isFinite(n)) {
+        return n;
+    }
+    else {
+        return null;
+    }
+}

package/src/platform-implementation-js/lib/dom/get-selection.js

@@ -1,61 +1,32 @@
-/* @flow */
+"use strict";
 
-import t from 'transducers.js';
-
-function isRangeEmpty(range: Range): boolean {
-  return (
-    range.startContainer === range.endContainer &&
-    range.startOffset === range.endOffset
-  );
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getSelectedHTMLInElement = getSelectedHTMLInElement;
+exports.getSelectedTextInElement = getSelectedTextInElement;
+var _transducers = _interopRequireDefault(require("transducers.js"));
+function isRangeEmpty(range) {
+  return range.startContainer === range.endContainer && range.startOffset === range.endOffset;
 }
 
 // returns true if either end appears to be inside the element
-function isRangeInElement(range: Range, el: HTMLElement): boolean {
+function isRangeInElement(range, el) {
   return el.contains(range.startContainer) || el.contains(range.endContainer);
 }
-
-function isRangeSuitable(range: Range, el: HTMLElement): boolean {
+function isRangeSuitable(range, el) {
   return !isRangeEmpty(range) && isRangeInElement(range, el);
 }
-
-export function getSelectedTextInElement(
-  element: HTMLElement,
-  lastRange?: ?Range
-): ?string {
-  const selection = (document: any).getSelection();
-  return t.toArray(
-    [
-      selection && selection.rangeCount ? selection.getRangeAt(0) : null,
-      lastRange,
-    ],
-    t.compose(
-      t.keep(),
-      t.filter((range: Range) => isRangeSuitable(range, element)),
-      t.map((range: Range) => range.toString()),
-      t.take(1)
-    )
-  )[0];
-}
-
-export function getSelectedHTMLInElement(
-  element: HTMLElement,
-  lastRange?: ?Range
-): ?string {
-  const selection = (document: any).getSelection();
-  return t.toArray(
-    [
-      selection && selection.rangeCount ? selection.getRangeAt(0) : null,
-      lastRange,
-    ],
-    t.compose(
-      t.keep(),
-      t.filter((range: Range) => isRangeSuitable(range, element)),
-      t.map((range: Range) => {
-        const div = document.createElement('div');
-        div.appendChild(range.cloneContents());
-        return div.innerHTML;
-      }),
-      t.take(1)
-    )
-  )[0];
+function getSelectedTextInElement(element, lastRange) {
+  const selection = document.getSelection();
+  return _transducers.default.toArray([selection && selection.rangeCount ? selection.getRangeAt(0) : null, lastRange], _transducers.default.compose(_transducers.default.keep(), _transducers.default.filter(range => isRangeSuitable(range, element)), _transducers.default.map(range => range.toString()), _transducers.default.take(1)))[0];
 }
+function getSelectedHTMLInElement(element, lastRange) {
+  const selection = document.getSelection();
+  return _transducers.default.toArray([selection && selection.rangeCount ? selection.getRangeAt(0) : null, lastRange], _transducers.default.compose(_transducers.default.keep(), _transducers.default.filter(range => isRangeSuitable(range, element)), _transducers.default.map(range => {
+    const div = document.createElement('div');
+    div.appendChild(range.cloneContents());
+    return div.innerHTML;
+  }), _transducers.default.take(1)))[0];
+}

package/src/platform-implementation-js/lib/dom/insert-element-in-order.js

@@ -0,0 +1,38 @@
+import t from 'transducers.js';
+const DEFAULT_ORDER_ATTRS = [
+    'data-group-order-hint',
+    'data-order-hint',
+    'data-insertion-order-hint',
+];
+export default function insertElementInOrder(container, el, orderAttrs = DEFAULT_ORDER_ATTRS, insertBeforeNonSdk = false) {
+    // get the first element with higher order hints
+    const insertBeforeElement = t.toArray(Array.prototype.slice.call(container.children), t.compose(t.filter((cel) => {
+        let hadAnyOrderAttrs = false;
+        for (const name of orderAttrs) {
+            const attr = el.getAttribute(name);
+            const cattr = cel.getAttribute(name);
+            if (attr == null || cattr == null)
+                continue;
+            hadAnyOrderAttrs = true;
+            let comparison;
+            if (!isNaN(parseFloat(attr)) && !isNaN(parseFloat(cattr))) {
+                comparison = parseFloat(cattr) - parseFloat(attr);
+            }
+            else {
+                comparison = cattr.localeCompare(attr);
+            }
+            if (comparison > 0)
+                return true;
+            if (comparison < 0)
+                return false;
+            // If the elements had equal hint values, then check the next hint.
+        }
+        if (insertBeforeNonSdk) {
+            return !hadAnyOrderAttrs;
+        }
+        else {
+            return false;
+        }
+    }), t.take(1)))[0];
+    container.insertBefore(el, insertBeforeElement);
+}