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

package/src/platform-implementation-js/lib/dom/simulate-drag-and-drop.js

@@ -1,15 +1,21 @@
-/* @flow */
+"use strict";
 
-import triggerRelayEvent from './trigger-relay-event';
-
-function makeDataTransferObj(files: Array<Blob | File>) {
-  const fileNames: Array<?string> = Array.from(files).map((file) =>
-    typeof file.name === 'string' ? file.name : undefined
-  );
-  return { files, fileNames };
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.simulateDragEnd = simulateDragEnd;
+exports.simulateDragOver = simulateDragOver;
+exports.simulateDrop = simulateDrop;
+var _triggerRelayEvent = _interopRequireDefault(require("./trigger-relay-event"));
+function makeDataTransferObj(files) {
+  const fileNames = Array.from(files).map(file => typeof file.name === 'string' ? file.name : undefined);
+  return {
+    files,
+    fileNames
+  };
 }
-
-export function simulateDragOver(element: HTMLElement, files: Blob[]) {
+function simulateDragOver(element, files) {
   const dataTransfer = makeDataTransferObj(files);
   const props = {
     screenX: 0,
@@ -21,27 +27,24 @@ export function simulateDragOver(element: HTMLElement, files: Blob[]) {
     shiftKey: false,
     altKey: false,
     metaKey: false,
-    detail: 0,
+    detail: 0
   };
-
-  triggerRelayEvent(element, {
+  (0, _triggerRelayEvent.default)(element, {
     type: 'dragenter',
     bubbles: true,
     cancelable: false,
     props,
-    dataTransfer,
+    dataTransfer
   });
-
-  triggerRelayEvent(element, {
+  (0, _triggerRelayEvent.default)(element, {
     type: 'dragover',
     bubbles: true,
     cancelable: false,
     props,
-    dataTransfer,
+    dataTransfer
   });
 }
-
-export function simulateDrop(element: HTMLElement, files: Blob[]) {
+function simulateDrop(element, files) {
   const dataTransfer = makeDataTransferObj(files);
   const props = {
     screenX: 0,
@@ -53,19 +56,17 @@ export function simulateDrop(element: HTMLElement, files: Blob[]) {
     shiftKey: false,
     altKey: false,
     metaKey: false,
-    detail: 0,
+    detail: 0
   };
-
-  triggerRelayEvent(element, {
+  (0, _triggerRelayEvent.default)(element, {
     type: 'drop',
     bubbles: true,
     cancelable: false,
     props,
-    dataTransfer,
+    dataTransfer
   });
 }
-
-export function simulateDragEnd(element: HTMLElement, files: Blob[]) {
+function simulateDragEnd(element, files) {
   const dataTransfer = makeDataTransferObj(files);
   const props = {
     screenX: 0,
@@ -77,22 +78,20 @@ export function simulateDragEnd(element: HTMLElement, files: Blob[]) {
     shiftKey: false,
     altKey: false,
     metaKey: false,
-    detail: 0,
+    detail: 0
   };
-
-  triggerRelayEvent(element, {
+  (0, _triggerRelayEvent.default)(element, {
     type: 'dragleave',
     bubbles: true,
     cancelable: false,
     props,
-    dataTransfer,
+    dataTransfer
   });
-
-  triggerRelayEvent(element, {
+  (0, _triggerRelayEvent.default)(element, {
     type: 'dragend',
     bubbles: true,
     cancelable: false,
     props,
-    dataTransfer,
+    dataTransfer
   });
-}
+}

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/extract-contact-from-email-contact-string.test.js

@@ -1,42 +1,39 @@
-/* @flow */
-
-import extractContactFromEmailContactString from './extract-contact-from-email-contact-string';
+"use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _extractContactFromEmailContactString = _interopRequireDefault(require("./extract-contact-from-email-contact-string"));
 it('should work with just an email address', () => {
-  expect(extractContactFromEmailContactString('monkeys@monkeys.com')).toEqual({
+  expect((0, _extractContactFromEmailContactString.default)('monkeys@monkeys.com')).toEqual({
     name: null,
-    emailAddress: 'monkeys@monkeys.com',
+    emailAddress: 'monkeys@monkeys.com'
   });
 });
-
 it('should work with a name', () => {
-  expect(
-    extractContactFromEmailContactString('George Monkey <monkeys@monkeys.com>')
-  ).toEqual({ name: 'George Monkey', emailAddress: 'monkeys@monkeys.com' });
+  expect((0, _extractContactFromEmailContactString.default)('George Monkey <monkeys@monkeys.com>')).toEqual({
+    name: 'George Monkey',
+    emailAddress: 'monkeys@monkeys.com'
+  });
 });
-
 it('should work spaces around an email address', () => {
-  expect(
-    extractContactFromEmailContactString('  monkeys@monkeys.com  ')
-  ).toEqual({ name: null, emailAddress: 'monkeys@monkeys.com' });
+  expect((0, _extractContactFromEmailContactString.default)('  monkeys@monkeys.com  ')).toEqual({
+    name: null,
+    emailAddress: 'monkeys@monkeys.com'
+  });
 });
-
 it('should work with spaces around a name', () => {
-  expect(
-    extractContactFromEmailContactString(
-      '  George Monkey <monkeys@monkeys.com>'
-    )
-  ).toEqual({ name: 'George Monkey', emailAddress: 'monkeys@monkeys.com' });
+  expect((0, _extractContactFromEmailContactString.default)('  George Monkey <monkeys@monkeys.com>')).toEqual({
+    name: 'George Monkey',
+    emailAddress: 'monkeys@monkeys.com'
+  });
 });
-
 it('throws on missing email address', () => {
   expect(() => {
-    extractContactFromEmailContactString('foo bar');
+    (0, _extractContactFromEmailContactString.default)('foo bar');
   }).toThrowError();
 });
-
 it('filters out U+202C', () => {
-  expect(
-    extractContactFromEmailContactString('Foo Bar <s@gmail.com\u202c>')
-  ).toEqual({ name: 'Foo Bar', emailAddress: 's@gmail.com' });
-});
+  expect((0, _extractContactFromEmailContactString.default)('Foo Bar <s@gmail.com\u202c>')).toEqual({
+    name: 'Foo Bar',
+    emailAddress: 's@gmail.com'
+  });
+});

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/handle-compose-link-chips.js

@@ -1,179 +1,116 @@
-/* @flow */
-
-import once from 'lodash/once';
-import Kefir from 'kefir';
-import { defn } from 'ud';
-import querySelector from './dom/querySelectorOrFail';
-import makeMutationObserverChunkedStream from './dom/make-mutation-observer-chunked-stream';
-import type { ComposeViewDriver } from '../driver-interfaces/compose-view-driver';
-
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _once = _interopRequireDefault(require("lodash/once"));
+var _kefir = _interopRequireDefault(require("kefir"));
+var _ud = require("ud");
+var _querySelectorOrFail = _interopRequireDefault(require("./dom/querySelectorOrFail"));
+var _makeMutationObserverChunkedStream = _interopRequireDefault(require("./dom/make-mutation-observer-chunked-stream"));
 const extId = '' + Math.random();
-
 const Z_SPACE_CHAR = '\u200b';
 const X_URL = 'https://ssl.gstatic.com/ui/v1/icons/common/x_8px.png';
-
-const handleComposeLinkChips = defn(
-  module,
-  function (composeView: ComposeViewDriver) {
-    // Abort if we're missing elements we'll need.
-    try {
-      composeView.getBodyElement();
-    } catch (err) {
-      return;
-    }
-
-    const mainElement = composeView.getElement();
-    _waitToClaim(mainElement)
-      .takeUntilBy(composeView.getStopper())
-      .onValue(() => {
-        mainElement.classList.add('inboxsdk__ensure_link_active');
-        composeView.getStopper().onValue(() => {
-          mainElement.classList.remove('inboxsdk__ensure_link_active');
-        });
-
-        composeView
-          .getEventStream()
-          .filter((event) => event.eventName === 'bodyChanged')
-          .toProperty(() => null)
-          .debounce(100, { immediate: true })
-          .takeUntilBy(composeView.getStopper())
-          .onValue(() => {
-            doFixing(composeView);
-          });
-
-        composeView
-          .getEventStream()
-          .filter((event) => event.eventName === 'presending')
-          .onValue(() => {
-            doPresendFixing(composeView);
-          });
-      });
+const handleComposeLinkChips = (0, _ud.defn)(module, function (composeView) {
+  // Abort if we're missing elements we'll need.
+  try {
+    composeView.getBodyElement();
+  } catch (err) {
+    return;
   }
-);
-export default handleComposeLinkChips;
-
-const doFixing = defn(
-  module,
-  function (composeView: ComposeViewDriver) {
-    const bodyElement = composeView.getBodyElement();
-    const chips = _getChipElements(bodyElement);
-
-    chips.filter(_isNotEnhanced).forEach(_addEnhancements);
-  },
-  'doFixing'
-);
-
-const doPresendFixing = defn(
-  module,
-  function (composeView: ComposeViewDriver) {
-    const bodyElement = composeView.getBodyElement();
-    const chips = _getChipElements(bodyElement);
-    chips.filter(_isOurEnhanced).forEach((chip) => {
-      const xBtn = chip.querySelector(`img[src="${X_URL}"]`);
-      if (xBtn) {
-        xBtn.remove();
-      }
-      const title = chip.querySelector('a > span');
-      if (title) {
-        title.style.textDecoration = 'none';
-      }
+  const mainElement = composeView.getElement();
+  _waitToClaim(mainElement).takeUntilBy(composeView.getStopper()).onValue(() => {
+    mainElement.classList.add('inboxsdk__ensure_link_active');
+    composeView.getStopper().onValue(() => {
+      mainElement.classList.remove('inboxsdk__ensure_link_active');
     });
-  },
-  'doPresendFixing'
-);
-
-function _getChipElements(bodyElement: HTMLElement): HTMLElement[] {
+    composeView.getEventStream().filter(event => event.eventName === 'bodyChanged').toProperty(() => null).debounce(100, {
+      immediate: true
+    }).takeUntilBy(composeView.getStopper()).onValue(() => {
+      doFixing(composeView);
+    });
+    composeView.getEventStream().filter(event => event.eventName === 'presending').onValue(() => {
+      doPresendFixing(composeView);
+    });
+  });
+});
+var _default = handleComposeLinkChips;
+exports.default = _default;
+const doFixing = (0, _ud.defn)(module, function (composeView) {
+  const bodyElement = composeView.getBodyElement();
+  const chips = _getChipElements(bodyElement);
+  chips.filter(_isNotEnhanced).forEach(_addEnhancements);
+}, 'doFixing');
+const doPresendFixing = (0, _ud.defn)(module, function (composeView) {
+  const bodyElement = composeView.getBodyElement();
+  const chips = _getChipElements(bodyElement);
+  chips.filter(_isOurEnhanced).forEach(chip => {
+    const xBtn = chip.querySelector(`img[src="${X_URL}"]`);
+    if (xBtn) {
+      xBtn.remove();
+    }
+    const title = chip.querySelector('a > span');
+    if (title) {
+      title.style.textDecoration = 'none';
+    }
+  });
+}, 'doPresendFixing');
+function _getChipElements(bodyElement) {
   const chipInnerEls = bodyElement.querySelectorAll('[hspace=inboxsdk__chip]');
-  return [
-    ...Array.from(chipInnerEls).map((x) => (x.parentElement: any)),
-    ...Array.from(bodyElement.querySelectorAll('[hspace=inboxsdk__chip_main]')),
-  ];
+  return [...Array.from(chipInnerEls).map(x => x.parentElement), ...Array.from(bodyElement.querySelectorAll('[hspace=inboxsdk__chip_main]'))];
 }
-
-function _waitToClaim(el: HTMLElement): Kefir.Observable<boolean> {
-  return Kefir.later(0)
-    .merge(
-      makeMutationObserverChunkedStream(el, {
-        attributes: true,
-        attributeFilter: ['class'],
-      })
-    )
-    .map(() => !el.classList.contains('inboxsdk__ensure_link_active'))
-    .filter(Boolean)
-    .take(1);
+function _waitToClaim(el) {
+  return _kefir.default.later(0).merge((0, _makeMutationObserverChunkedStream.default)(el, {
+    attributes: true,
+    attributeFilter: ['class']
+  })).map(() => !el.classList.contains('inboxsdk__ensure_link_active')).filter(Boolean).take(1);
 }
-
-function _isNotEnhanced(chipElement: HTMLElement): boolean {
+function _isNotEnhanced(chipElement) {
   var claim = chipElement.getAttribute('data-sdk-linkchip-claimed');
   if (extId === claim) {
-    return !(chipElement: any)._linkChipEnhancedByThisExtension;
+    return !chipElement._linkChipEnhancedByThisExtension;
   }
   return claim == null;
 }
 
 // Returns whether the chip is enhanced specifically by this extension
-function _isOurEnhanced(chipElement: HTMLElement): boolean {
-  return !!(chipElement: any)._linkChipEnhancedByThisExtension;
+function _isOurEnhanced(chipElement) {
+  return !!chipElement._linkChipEnhancedByThisExtension;
 }
-
-function _addEnhancements(chipElement: HTMLElement) {
+function _addEnhancements(chipElement) {
   const anchor = chipElement.querySelector('a');
   if (anchor) {
-    anchor.addEventListener(
-      'mousedown',
-      function (e: MouseEvent) {
-        e.stopImmediatePropagation();
-      },
-      true
-    );
-    anchor.addEventListener(
-      'click',
-      function (e: MouseEvent) {
-        e.stopImmediatePropagation();
-      },
-      true
-    );
+    anchor.addEventListener('mousedown', function (e) {
+      e.stopImmediatePropagation();
+    }, true);
+    anchor.addEventListener('click', function (e) {
+      e.stopImmediatePropagation();
+    }, true);
   }
-
   const xElement = document.createElement('img');
   xElement.src = X_URL;
-  xElement.setAttribute(
-    'style',
-    'opacity: 0.55; cursor: pointer; float: right; position: relative; top: -1px;'
-  );
-
-  xElement.addEventListener(
-    'mousedown',
-    function (e: MouseEvent) {
-      chipElement.remove();
-    },
-    true
-  );
-
-  xElement.addEventListener(
-    'click',
-    function (e: MouseEvent) {
-      e.stopImmediatePropagation();
-      e.preventDefault();
-    },
-    true
-  );
-
+  xElement.setAttribute('style', 'opacity: 0.55; cursor: pointer; float: right; position: relative; top: -1px;');
+  xElement.addEventListener('mousedown', function (e) {
+    chipElement.remove();
+  }, true);
+  xElement.addEventListener('click', function (e) {
+    e.stopImmediatePropagation();
+    e.preventDefault();
+  }, true);
   chipElement.addEventListener('mouseenter', function () {
     chipElement.appendChild(xElement);
-    querySelector(chipElement, 'a > span').style.textDecoration = 'underline';
+    (0, _querySelectorOrFail.default)(chipElement, 'a > span').style.textDecoration = 'underline';
   });
-
   chipElement.addEventListener('mouseleave', function () {
-    (xElement: any).remove();
-    querySelector(chipElement, 'a > span').style.textDecoration = 'none';
+    xElement.remove();
+    (0, _querySelectorOrFail.default)(chipElement, 'a > span').style.textDecoration = 'none';
   });
-
-  chipElement.addEventListener('mousedown', function (e: MouseEvent) {
+  chipElement.addEventListener('mousedown', function (e) {
     e.preventDefault();
   });
-
   chipElement.contentEditable = 'false';
   chipElement.setAttribute('data-sdk-linkchip-claimed', extId);
-  (chipElement: any)._linkChipEnhancedByThisExtension = true;
-}
+  chipElement._linkChipEnhancedByThisExtension = true;
+}

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