@inboxsdk/core 1.2.5 → 1.2.8-0

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

@@ -1,137 +0,0 @@
-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,35 +0,0 @@
-export default 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') {
-            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.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 {
-                    console.error('Support for iconURL property was dropped after API version 1');
-                }
-            }
-            delete resultCopy.iconURL;
-        }
-        return resultCopy;
-    });
-}

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

@@ -1,6 +0,0 @@
-export default 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

@@ -1,10 +0,0 @@
-import asap from 'asap';
-import * as Kefir from 'kefir';
-export default function delayAsap(value) {
-    return Kefir.stream((emitter) => {
-        asap(() => {
-            emitter.emit(value);
-            emitter.end();
-        });
-    });
-}

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

@@ -1,16 +0,0 @@
-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

@@ -1,36 +0,0 @@
-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/custom-events.js

@@ -1,5 +0,0 @@
-export var CustomDomEvent;
-(function (CustomDomEvent) {
-    CustomDomEvent["tellMeThisThreadIdByDatabase"] = "inboxSDKtellMeThisThreadIdByDatabase";
-    CustomDomEvent["tellMeThisThreadIdByClick"] = "inboxSDKtellMeThisThreadIdByClick";
-})(CustomDomEvent || (CustomDomEvent = {}));

package/src/platform-implementation-js/lib/dom/element-view-mapper.js

@@ -1,9 +0,0 @@
-export default 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

@@ -1,39 +0,0 @@
-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

@@ -1,39 +0,0 @@
-// 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,30 +0,0 @@
-import t from '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, el) {
-    return el.contains(range.startContainer) || el.contains(range.endContainer);
-}
-function isRangeSuitable(range, el) {
-    return !isRangeEmpty(range) && isRangeInElement(range, el);
-}
-export function getSelectedTextInElement(element, lastRange) {
-    const selection = document.getSelection();
-    return t.toArray([
-        selection && selection.rangeCount ? selection.getRangeAt(0) : null,
-        lastRange,
-    ], t.compose(t.keep(), t.filter((range) => isRangeSuitable(range, element)), t.map((range) => range.toString()), t.take(1)))[0];
-}
-export function getSelectedHTMLInElement(element, lastRange) {
-    const selection = document.getSelection();
-    return t.toArray([
-        selection && selection.rangeCount ? selection.getRangeAt(0) : null,
-        lastRange,
-    ], t.compose(t.keep(), t.filter((range) => isRangeSuitable(range, element)), t.map((range) => {
-        const div = document.createElement('div');
-        div.appendChild(range.cloneContents());
-        return div.innerHTML;
-    }), t.take(1)))[0];
-}

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

@@ -1,38 +0,0 @@
-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);
-}

package/src/platform-implementation-js/lib/dom/insert-html-at-cursor.js

@@ -1,83 +0,0 @@
-import * as ud from 'ud';
-import Kefir from 'kefir';
-var insertHTMLatCursor = ud.defn(module, function insertHTMLatCursor(element, html, oldRange) {
-    element.focus();
-    if (element instanceof HTMLTextAreaElement) {
-        var oldStart = element.selectionStart;
-        // first delete selected range
-        if (element.selectionStart < element.selectionEnd) {
-            element.value =
-                element.value.substring(0, element.selectionStart) +
-                    element.value.substring(element.selectionEnd);
-        }
-        // insert into position
-        element.value =
-            element.value.substring(0, oldStart) +
-                html +
-                element.value.substring(oldStart);
-        // set caret
-        element.selectionStart = oldStart + html.length;
-        element.selectionEnd = oldStart + html.length;
-    }
-    else {
-        var editable = null;
-        if (element.getSelection) {
-            editable = element;
-        }
-        else if (element.ownerDocument &&
-            element.ownerDocument.getSelection) {
-            editable = element.ownerDocument;
-        }
-        if (editable) {
-            var sel = editable.getSelection();
-            if (sel.getRangeAt && sel.rangeCount) {
-                var range = oldRange || sel.getRangeAt(0);
-                range.deleteContents();
-                var frag;
-                if (html instanceof DocumentFragment) {
-                    frag = html;
-                }
-                else {
-                    frag = document.createDocumentFragment();
-                    if (html instanceof HTMLElement) {
-                        frag.appendChild(html);
-                    }
-                    else {
-                        var el = document.createElement('div');
-                        el.innerHTML = html;
-                        var node;
-                        while ((node = el.firstChild)) {
-                            frag.appendChild(node);
-                        }
-                    }
-                }
-                var firstChild = frag.firstElementChild;
-                range.insertNode(frag);
-                // Simulate a mousedown event to kill any existing focus-fixers.
-                var event = document.createEvent('MouseEvents');
-                event.initMouseEvent('mousedown', false, true, window, 1, 0, 0, 0, 0, false, false, false, false, 0, null);
-                event.preventDefault();
-                element.dispatchEvent(event);
-                // Preserve the cursor position
-                range.collapse(false);
-                sel.removeAllRanges();
-                sel.addRange(range);
-                var nextUserCursorMove = Kefir.merge([
-                    Kefir.fromEvents(element, 'mousedown'),
-                    Kefir.fromEvents(element, 'keypress'),
-                ]);
-                // Whenever the body element gets focus, manually make sure the cursor
-                // is in the right position, because Chrome likes to put it in the
-                // previous location instead because it hates us.
-                Kefir.fromEvents(element, 'focus')
-                    .takeUntilBy(nextUserCursorMove)
-                    .onValue(function () {
-                    sel.removeAllRanges();
-                    sel.addRange(range);
-                });
-                return firstChild;
-            }
-        }
-    }
-});
-export default insertHTMLatCursor;

package/src/platform-implementation-js/lib/dom/is-node-in-range.js

@@ -1,12 +0,0 @@
-export default function isNodeInRange(node, range) {
-    if (!range) {
-        return false;
-    }
-    if (!node) {
-        return false;
-    }
-    const newRange = document.createRange();
-    newRange.selectNode(node);
-    return (newRange.compareBoundaryPoints(Range.START_TO_END, range) < 1 &&
-        range.compareBoundaryPoints(Range.START_TO_END, newRange) < 1);
-}

package/src/platform-implementation-js/lib/dom/keyboard-shortcut-stream.js

@@ -1,12 +0,0 @@
-import * as Kefir from 'kefir';
-import Combokeys from 'combokeys-capture';
-const combokeys = typeof document !== 'undefined' && new Combokeys(document.body, true);
-export default function keyboardShortcutStream(chord) {
-    return Kefir.stream((emitter) => {
-        return (combokeys &&
-            combokeys.bind(chord, function (domEvent) {
-                emitter.emit(domEvent);
-                return false;
-            }, 'keydown'));
-    });
-}

package/src/platform-implementation-js/lib/dom/make-element-child-stream.js

@@ -1,79 +0,0 @@
-import asap from 'asap';
-import * as Kefir from 'kefir';
-import kefirStopper from 'kefir-stopper';
-// Emits events whenever the given element has any children added or removed.
-// Also when first listened to, it emits events for existing children.
-export default function makeElementChildStream(element) {
-    if (!element || !element.nodeType) {
-        throw new Error('Expected element, got ' + String(element));
-    }
-    return Kefir.stream((emitter) => {
-        const removalStreams = new Map();
-        let ended = false;
-        function newEl(el) {
-            if (el.nodeType !== 1)
-                return;
-            if (removalStreams.has(el)) {
-                throwLater(new Error('Already had removalStream for element with class ' + el.className));
-            }
-            const removalStream = kefirStopper();
-            removalStreams.set(el, removalStream);
-            try {
-                emitter.emit({ el, removalStream });
-            }
-            catch (err) {
-                throwLater(err);
-            }
-        }
-        function removedEl(el) {
-            if (el.nodeType !== 1)
-                return;
-            const removalStream = removalStreams.get(el);
-            removalStreams.delete(el);
-            if (removalStream) {
-                try {
-                    removalStream.destroy();
-                }
-                catch (err) {
-                    throwLater(err);
-                }
-            }
-            else {
-                throwLater(new Error('Could not find removalStream for element with class ' +
-                    el.className));
-            }
-        }
-        const observer = new MutationObserver(function (mutations) {
-            mutations.forEach((mutation) => {
-                Array.prototype.forEach.call(mutation.addedNodes, newEl);
-                Array.prototype.forEach.call(mutation.removedNodes, removedEl);
-            });
-        });
-        // We don't want to emit the start children synchronously before all
-        // stream listeners are subscribed.
-        asap(() => {
-            if (!ended) {
-                observer.observe(element, { childList: true });
-                // Clone child list first because it can change
-                Array.prototype.slice.call(element.children).forEach(newEl);
-            }
-        });
-        return function () {
-            ended = true;
-            observer.disconnect();
-            asap(() => {
-                removalStreams.forEach((removalStream) => {
-                    removalStream.destroy();
-                });
-            });
-        };
-    });
-}
-// Throw error at a later time where our error-logger can pick it up. This
-// avoids having this module depend on logger.js which we can't import because
-// this module is used in the injected script too.
-function throwLater(err) {
-    setTimeout(() => {
-        throw err;
-    }, 1);
-}

package/src/platform-implementation-js/lib/dom/make-element-stream-merger.js

@@ -1,27 +0,0 @@
-import * as Kefir from 'kefir';
-import StopperPool from '../stopper-pool';
-import delayAsap from '../delay-asap';
-export default function makeElementStreamMerger() {
-    const knownElementStopperPools = new Map();
-    return (event) => {
-        let stopperPool = knownElementStopperPools.get(event.el);
-        if (stopperPool) {
-            if (stopperPool.getSize() > 1) {
-                console.warn('element is part of multiple element streams', stopperPool.getSize(), event.el);
-            }
-            stopperPool.add(event.removalStream.flatMap(delayAsap));
-            return Kefir.never();
-        }
-        else {
-            stopperPool = new StopperPool(event.removalStream.flatMap(delayAsap));
-            stopperPool.stream.onValue(function () {
-                knownElementStopperPools.delete(event.el);
-            });
-            knownElementStopperPools.set(event.el, stopperPool);
-            return Kefir.constant({
-                el: event.el,
-                removalStream: stopperPool.stream,
-            });
-        }
-    };
-}

package/src/platform-implementation-js/lib/dom/make-element-view-stream.js

@@ -1,15 +0,0 @@
-import * as Kefir from 'kefir';
-export default function makeElementViewStream(viewFn) {
-    return (event) => {
-        const view = viewFn(event.el);
-        if (view) {
-            event.removalStream.take(1).onValue(() => {
-                view.destroy();
-            });
-            return Kefir.constant(view);
-        }
-        else {
-            return Kefir.never();
-        }
-    };
-}

package/src/platform-implementation-js/lib/dom/make-mutation-observer-chunked-stream.js

@@ -1,15 +0,0 @@
-import * as Kefir from 'kefir';
-// Creates a mutation observer watching the given element and emits the events in a stream.
-export default function makeMutationObserverChunkedStream(element, options) {
-    return Kefir.stream((emitter) => {
-        const observer = new MutationObserver((mutations) => {
-            // Work around Safari bug where sometimes mutations is an instance of a
-            // different context's Array.
-            emitter.emit(mutations instanceof Array ? mutations : Array.from(mutations));
-        });
-        observer.observe(element, options);
-        return () => {
-            observer.disconnect();
-        };
-    });
-}

package/src/platform-implementation-js/lib/dom/make-mutation-observer-stream.js

@@ -1,5 +0,0 @@
-import makeMutationObserverChunkedStream from './make-mutation-observer-chunked-stream';
-// Creates a mutation observer watching the given element and emits the events in a stream.
-export default function makeMutationObserverStream(element, options) {
-    return makeMutationObserverChunkedStream(element, options).flatten();
-}