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

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

@@ -1,113 +1,81 @@
-/* @flow */
+"use strict";
 
-import * as ud from 'ud';
-import Kefir from 'kefir';
-
-var insertHTMLatCursor = ud.defn(
-  module,
-  function insertHTMLatCursor(
-    element: HTMLElement,
-    html: string,
-    oldRange: ?Object
-  ): ?HTMLElement {
-    element.focus();
-
-    if (element instanceof HTMLTextAreaElement) {
-      var oldStart = (element: any).selectionStart;
-      // first delete selected range
-      if ((element: any).selectionStart < (element: any).selectionEnd) {
-        element.value =
-          element.value.substring(0, (element: any).selectionStart) +
-          element.value.substring((element: any).selectionEnd);
-      }
-      // insert into position
-      element.value =
-        element.value.substring(0, oldStart) +
-        html +
-        element.value.substring(oldStart);
-      // set caret
-      (element: any).selectionStart = oldStart + html.length;
-      (element: any).selectionEnd = oldStart + html.length;
-    } else {
-      var editable = null;
-      if ((element: any).getSelection) {
-        editable = element;
-      } else if (element.ownerDocument && element.ownerDocument.getSelection) {
-        editable = element.ownerDocument;
-      }
-
-      if (editable) {
-        var sel = (editable: any).getSelection();
-        if (sel.getRangeAt && sel.rangeCount) {
-          var range = oldRange || sel.getRangeAt(0);
-          range.deleteContents();
-
-          var frag;
-          if (html instanceof DocumentFragment) {
-            frag = html;
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var ud = _interopRequireWildcard(require("ud"));
+var _kefir = _interopRequireDefault(require("kefir"));
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+var 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 {
-            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 el = document.createElement('div');
+            el.innerHTML = html;
+            var node;
+            while (node = el.firstChild) {
+              frag.appendChild(node);
             }
           }
+        }
+        var firstChild = frag.firstElementChild;
+        range.insertNode(frag);
 
-          var firstChild: HTMLElement = (frag: any).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);
 
-          // Simulate a mousedown event to kill any existing focus-fixers.
-          var event = document.createEvent('MouseEvents');
-          (event: any).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.default.merge([_kefir.default.fromEvents(element, 'mousedown'), _kefir.default.fromEvents(element, 'keypress')]);
 
-          // Preserve the cursor position
-          range.collapse(false);
+        // 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.
+        var focus = _kefir.default.fromEvents(element, 'focus').takeUntilBy(nextUserCursorMove).onValue(function () {
           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.
-          var focus = Kefir.fromEvents(element, 'focus')
-            .takeUntilBy(nextUserCursorMove)
-            .onValue(function () {
-              sel.removeAllRanges();
-              sel.addRange(range);
-            });
-
-          return firstChild;
-        }
+        });
+        return firstChild;
       }
     }
   }
-);
-export default insertHTMLatCursor;
+});
+var _default = insertHTMLatCursor;
+exports.default = _default;

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

@@ -1,19 +1,17 @@
-/* @flow */
+"use strict";
 
-export default function isNodeInRange(node: ?Node, range: ?Range): boolean {
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = isNodeInRange;
+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
-  );
-}
+  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

@@ -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/on-mouse-down-and-up.js

@@ -1,19 +1,17 @@
-/* @flow */
+"use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _fromEventTargetCapture = _interopRequireDefault(require("../from-event-target-capture"));
+var _ud = require("ud");
 const Kefir = require('kefir');
-import fromEventTargetCapture from '../from-event-target-capture';
-import { defn } from 'ud';
-
-const pageMouseUps = fromEventTargetCapture((document.body: any), 'mouseup');
-
-const onMouseDownAndUp = defn(
-  module,
-  function onMouseDownAndUp(el: HTMLElement): Kefir.Observable<Event> {
-    const elMouseDowns = fromEventTargetCapture(el, 'mousedown');
-    return elMouseDowns.flatMapLatest(() =>
-      pageMouseUps.take(1).filter((event) => el.contains(event.target))
-    );
-  }
-);
-
-export default onMouseDownAndUp;
+const pageMouseUps = (0, _fromEventTargetCapture.default)(document.body, 'mouseup');
+const onMouseDownAndUp = (0, _ud.defn)(module, function onMouseDownAndUp(el) {
+  const elMouseDowns = (0, _fromEventTargetCapture.default)(el, 'mousedown');
+  return elMouseDowns.flatMapLatest(() => pageMouseUps.take(1).filter(event => el.contains(event.target)));
+});
+var _default = onMouseDownAndUp;
+exports.default = _default;

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

@@ -1,16 +1,13 @@
-/* @flow */
+"use strict";
 
-export default function querySelectorOne(
-  root: Element,
-  selector: string
-): HTMLElement {
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = querySelectorOne;
+function querySelectorOne(root, selector) {
   const els = root.querySelectorAll(selector);
   if (els.length !== 1) {
-    throw new Error(
-      `Found ${
-        els.length
-      } elements when expecting 1 using selector ${JSON.stringify(selector)}`
-    );
+    throw new Error(`Found ${els.length} elements when expecting 1 using selector ${JSON.stringify(selector)}`);
   }
   return els[0];
-}
+}

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/set-css.js

@@ -1,7 +1,11 @@
-/* @flow */
+"use strict";
 
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = setCss;
 // For quick temporary CSS changes
-export default function setCss(key: string, css: ?string) {
+function setCss(key, css) {
   const id = `inboxsdk__${key}`;
   let style = document.getElementById(id);
   if (!css) {
@@ -18,4 +22,4 @@ export default function setCss(key: string, css: ?string) {
     document.head.appendChild(style);
   }
   style.textContent = css;
-}
+}

package/src/platform-implementation-js/lib/dom/set-value-and-dispatch-event.js

@@ -1,14 +1,12 @@
-/* @flow */
-
-export default function setValueAndDispatchInputEvent(
-  element: HTMLElement,
-  value: string,
-  eventName: string
-) {
-  (element: any).value = value;
+"use strict";
 
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = setValueAndDispatchInputEvent;
+function setValueAndDispatchInputEvent(element, value, eventName) {
+  element.value = value;
   const event = document.createEvent('Event');
-  (event: any).initEvent(eventName);
-
+  event.initEvent(eventName);
   element.dispatchEvent(event);
-}
+}