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

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

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

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

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

@@ -0,0 +1,28 @@
+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) {
+                // eslint-disable-next-line no-console
+                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

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

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

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

package/src/platform-implementation-js/lib/dom/outsideClicksAndEscape.js

@@ -0,0 +1,39 @@
+import * as Kefir from 'kefir';
+import fromEventTargetCapture from '../from-event-target-capture';
+import parentNodes from './parentNodes';
+export default function outsideClicksAndEscape(elements) {
+    return Kefir.merge([
+        fromEventTargetCapture(document, 'click'),
+        // We modify the focus event on document sometimes, so we listen for
+        // it on body so our modifications can happen first.
+        fromEventTargetCapture(document.body, 'focus'),
+    ])
+        .filter((event) => !event.shouldIgnore &&
+        (event.isTrusted ||
+            (process.env.NODE_ENV === 'test' && event.__testAllow)) &&
+        elements.every((el) => {
+            for (const node of parentNodes(event.target)) {
+                if (node === el)
+                    return false;
+            }
+            return true;
+        }))
+        .map((event) => ({ type: 'outsideInteraction', cause: event }))
+        .merge(Kefir.fromEvents(document, 'keydown')
+        .filter((e) => (e.key ? e.key === 'Escape' : e.which === 27))
+        .map((event) => {
+        event.preventDefault();
+        event.stopPropagation();
+        return { type: 'escape', cause: event };
+    }))
+        .map((e) => {
+        if (process.env.NODE_ENV !== 'production') {
+            const allElsStillInPage = elements.every((el) => document.contains(el));
+            if (!allElsStillInPage) {
+                // eslint-disable-next-line no-console
+                console.error('outsideClicksAndEscape not unsubscribed from when elements were removed from the page');
+            }
+        }
+        return e;
+    });
+}

package/src/platform-implementation-js/lib/dom/parentNodes.js

@@ -0,0 +1,8 @@
+export default function* parentNodes(node) {
+    do {
+        yield node;
+    } while ((node =
+        node.rfaAnchor ||
+            node._logicalParent ||
+            node.parentNode));
+}

package/src/platform-implementation-js/lib/dom/querySelectorOrFail.js

@@ -0,0 +1,6 @@
+export default function querySelector(el, selector) {
+    const r = el.querySelector(selector);
+    if (!r)
+        throw new Error(`Failed to find element with selector: ${selector}`);
+    return r;
+}

package/src/platform-implementation-js/lib/dom/reemitClickEventForReact.js

@@ -0,0 +1,22 @@
+export default function reemitClickEvent(event) {
+    // Inbox is going to block this event from bubbling to the body. We
+    // want to manually dispatch an event that looks like it so that if
+    // the extension is using React (which listens to events on the body)
+    // then React will see it.
+    const fakeEvent = new MouseEvent('click');
+    Object.defineProperties(fakeEvent, {
+        target: { value: event.target },
+        detail: { value: event.detail },
+        screenX: { value: event.screenX },
+        screenY: { value: event.screenY },
+        clientX: { value: event.clientX },
+        clientY: { value: event.clientY },
+        button: { value: event.button },
+        buttons: { value: event.buttons },
+        ctrlKey: { value: event.ctrlKey },
+        shiftKey: { value: event.shiftKey },
+        altKey: { value: event.altKey },
+        metaKey: { value: event.metaKey },
+    });
+    document.dispatchEvent(fakeEvent);
+}

package/src/platform-implementation-js/lib/dom/simulate-key.js

@@ -0,0 +1,46 @@
+import triggerRelayEvent from './trigger-relay-event';
+export default function simulateKey(element, keyCode, charCode) {
+    const ctrlKey = false;
+    const metaKey = false;
+    const altKey = false;
+    const shiftKey = false;
+    triggerRelayEvent(element, {
+        type: 'keydown',
+        bubbles: true,
+        cancelable: true,
+        props: {
+            keyCode,
+            charCode,
+            ctrlKey,
+            metaKey,
+            altKey,
+            shiftKey,
+        },
+    });
+    triggerRelayEvent(element, {
+        type: 'keypress',
+        bubbles: true,
+        cancelable: true,
+        props: {
+            keyCode,
+            charCode,
+            ctrlKey,
+            metaKey,
+            altKey,
+            shiftKey,
+        },
+    });
+    triggerRelayEvent(element, {
+        type: 'keyup',
+        bubbles: true,
+        cancelable: true,
+        props: {
+            keyCode,
+            charCode,
+            ctrlKey,
+            metaKey,
+            altKey,
+            shiftKey,
+        },
+    });
+}

package/src/platform-implementation-js/lib/dom/simulate-mouse-event.js

@@ -0,0 +1,16 @@
+export default function simulateMouseEvent(element, mouseEventName) {
+    const event = document.createEvent('MouseEvents');
+    event.initMouseEvent(mouseEventName, true, true, window, 0, element.offsetLeft, element.offsetTop, 0, 0, false, false, false, false, 0, null);
+    element.dispatchEvent(event);
+}
+export function simulateHover(element) {
+    simulateMouseEvent(element, 'mouseover');
+}
+export function simulateClick(element) {
+    simulateMouseEvent(element, 'mousedown');
+    simulateMouseEvent(element, 'mouseup');
+    simulateMouseEvent(element, 'click');
+    simulateMouseEvent(element, 'mouseleave');
+    simulateMouseEvent(element, 'mouseout');
+    element.blur();
+}

package/src/platform-implementation-js/lib/dom/trigger-relay-event.js

@@ -0,0 +1,7 @@
+export default async function triggerRelayEvent(element, detail) {
+    element.dispatchEvent(new CustomEvent('inboxsdk_event_relay', {
+        bubbles: true,
+        cancelable: false,
+        detail,
+    }));
+}

package/src/platform-implementation-js/lib/extract-contact-from-email-contact-string.js

@@ -0,0 +1,25 @@
+import isValidEmail from './is-valid-email';
+export default function extractContactFromEmailContactString(contactInfoString) {
+    let name = null;
+    let emailAddress = null;
+    const contactInfoParts = contactInfoString.split('<');
+    const firstPartTrimmed = contactInfoParts[0].replace(/\u202c/g, '').trim();
+    if (contactInfoParts.length > 1) {
+        name = firstPartTrimmed;
+        emailAddress = contactInfoParts[1]
+            .split('>')[0]
+            .replace(/\u202c/g, '')
+            .trim();
+    }
+    else {
+        if (isValidEmail(firstPartTrimmed)) {
+            emailAddress = firstPartTrimmed;
+        }
+        else {
+            throw Object.assign(new Error('Invalid email address'), {
+                firstPartTrimmed,
+            });
+        }
+    }
+    return { name, emailAddress };
+}

package/src/platform-implementation-js/lib/fake-window-resize.js

@@ -0,0 +1,5 @@
+export default function fakeWindowResize() {
+    const event = document.createEvent('HTMLEvents');
+    event.initEvent('resize', true, false);
+    window.dispatchEvent(event);
+}

package/src/platform-implementation-js/lib/from-event-target-capture.js

@@ -0,0 +1,12 @@
+import * as Kefir from 'kefir';
+export default function fromEventTargetCapture(target, eventName) {
+    return Kefir.stream((emitter) => {
+        function sink(event) {
+            emitter.value(event);
+        }
+        target.addEventListener(eventName, sink, true);
+        return () => {
+            target.removeEventListener(eventName, sink, true);
+        };
+    });
+}

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

@@ -0,0 +1,10 @@
+import * as Kefir from 'kefir';
+import { addEventListener, removeEventListener, } from 'event-listener-with-options';
+export default function fromEventsWithOptions(target, eventName, options) {
+    return Kefir.stream((emitter) => {
+        addEventListener(target, eventName, emitter.emit, options);
+        return () => {
+            removeEventListener(target, eventName, emitter.emit, options);
+        };
+    });
+}

package/src/platform-implementation-js/lib/handler-registry.js

@@ -0,0 +1,67 @@
+import remove from 'lodash/remove';
+import asap from 'asap';
+import Logger from './logger';
+export default class HandlerRegistry {
+    _targets = [];
+    _pendingHandlers = [];
+    _handlers = [];
+    registerHandler(handler) {
+        if (this._pendingHandlers.indexOf(handler) === -1) {
+            this._pendingHandlers.push(handler);
+            asap(() => {
+                const pendingHandlers = this._pendingHandlers.slice();
+                for (let ii = pendingHandlers.length - 1; ii >= 0; ii--) {
+                    const handler = pendingHandlers[ii];
+                    if (this._handlers.indexOf(handler) === -1) {
+                        this._handlers.push(handler);
+                        this._informHandlerOfTargets(handler);
+                    }
+                }
+                this._pendingHandlers = [];
+            });
+        }
+        return () => {
+            remove(this._pendingHandlers, (h) => h === handler);
+            remove(this._handlers, (h) => h === handler);
+        };
+    }
+    addTarget(target) {
+        this._targets.push(target);
+        // TODO should we error if an object without an .on method is added?
+        if (target &&
+            typeof target === 'object' &&
+            typeof target.on === 'function') {
+            target.on('destroy', () => {
+                this.removeTarget(target);
+            });
+        }
+        this._informHandlersOfTarget(target);
+    }
+    removeTarget(target) {
+        remove(this._targets, (t) => t === target);
+    }
+    dumpHandlers() {
+        this._pendingHandlers = [];
+        this._handlers = [];
+    }
+    _informHandlerOfTargets(handler) {
+        const targets = this._targets.slice();
+        for (let ii = 0; ii < targets.length; ii++) {
+            _tryCatch(handler, targets[ii]);
+        }
+    }
+    _informHandlersOfTarget(target) {
+        const handlers = this._handlers.slice();
+        for (let ii = 0; ii < handlers.length; ii++) {
+            _tryCatch(handlers[ii], target);
+        }
+    }
+}
+function _tryCatch(fn, arg) {
+    try {
+        fn(arg);
+    }
+    catch (err) {
+        Logger.error(err);
+    }
+}

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

@@ -0,0 +1,45 @@
+import Sha256 from 'sha.js/sha256';
+const cache = new Map();
+let seed = null;
+let useDevMode = false;
+// Pass a name and you'll get a unique identifier associated with that name.
+// The returned identifier will only contain alphabetic characters.
+export default function idMap(name) {
+    const id = cache.get(name);
+    if (id != null)
+        return id;
+    if (seed == null) {
+        seed = document.documentElement.getAttribute('data-map-id');
+        if (seed == null) {
+            // Make the seed change every hour: the seed is based on a hash of the
+            // current timestamp in hour resolution.
+            const hasher = new Sha256();
+            hasher.update('PWVe' + Math.floor(Date.now() / (1000 * 60 * 60)) + 'PYiE0');
+            seed =
+                hasher.digest('hex').slice(0, 16) +
+                    (process.env.NODE_ENV === 'development' ? 'x' : '');
+            document.documentElement.setAttribute('data-map-id', seed);
+        }
+        useDevMode = /x$/.test(seed);
+    }
+    let newId;
+    if (useDevMode) {
+        const n = String(seed.charCodeAt(0) % 10);
+        newId = `idm${n}_${name}`;
+    }
+    else {
+        const hasher = new Sha256();
+        hasher.update('4iYi29W' + name + ':' + seed + 'jn2mPvTG');
+        newId = hasher
+            .digest('hex')
+            .slice(0, 16)
+            .replace(/[0-9]/g, (match) => String.fromCharCode('A'.charCodeAt(0) + Number(match)));
+    }
+    cache.set(name, newId);
+    return newId;
+}
+// Only exposed for tests!
+export function _reset() {
+    cache.clear();
+    seed = null;
+}

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

@@ -0,0 +1,8 @@
+export default function imageRequest(url) {
+    return new Promise((resolve, reject) => {
+        const img = new Image();
+        img.addEventListener('load', () => resolve(img));
+        img.addEventListener('error', reject);
+        img.src = url;
+    });
+}

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

@@ -0,0 +1,7 @@
+export default function incrementName(name) {
+    const m = / (\d+)$/.exec(name);
+    if (m) {
+        return name.slice(0, name.length - m[0].length) + ' ' + (Number(m[1]) + 1);
+    }
+    return name + ' 2';
+}

package/src/platform-implementation-js/lib/inject-script-EMBEDDED.js

@@ -0,0 +1,14 @@
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const fs = require('fs');
+export function injectScriptEmbedded() {
+    const url = 'https://www.inboxsdk.com/build/pageWorld.js';
+    const script = document.createElement('script');
+    script.type = 'text/javascript';
+    const originalCode = fs.readFileSync(__dirname + '/../../../dist/pageWorld.js', 'utf8');
+    const codeParts = [];
+    codeParts.push(originalCode);
+    codeParts.push('\n//# sourceURL=' + url + '\n');
+    const codeToRun = codeParts.join('');
+    script.text = codeToRun;
+    document.head.appendChild(script).parentNode.removeChild(script);
+}

package/src/platform-implementation-js/lib/inject-script.js

@@ -0,0 +1,33 @@
+import once from 'lodash/once';
+import Kefir from 'kefir';
+import makeMutationObserverChunkedStream from './dom/make-mutation-observer-chunked-stream';
+let injectScriptImplementation = () => {
+    window.chrome.runtime.sendMessage({ type: 'inboxsdk__injectPageWorld' }, (didExecute) => {
+        if (!didExecute) {
+            // MV2 support
+            const scr = document.createElement('script');
+            scr.type = 'text/javascript';
+            scr.src = window.chrome.runtime.getURL('pageWorld.js');
+            document.documentElement.appendChild(scr);
+        }
+    });
+};
+// Returns a promise that resolves once the injected script has been injected
+// and has done its initial load stuff.
+export const injectScript = once(() => {
+    if (!document.head.hasAttribute('data-inboxsdk-script-injected')) {
+        document.head.setAttribute('data-inboxsdk-script-injected', 'true');
+        injectScriptImplementation();
+    }
+    return Kefir.later(0, null)
+        .merge(makeMutationObserverChunkedStream(document.head, {
+        attributes: true,
+    }))
+        .filter(() => document.head.hasAttribute('data-inboxsdk-user-email-address'))
+        .take(1)
+        .map(() => null)
+        .toPromise();
+});
+export function setInjectScriptImplementation(fn) {
+    injectScriptImplementation = fn;
+}

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