@inboxsdk/core 0.2.28-alpha.0 → 0.2.28-alpha.2

package/src/platform-implementation-js/dom-driver/inbox/addRecipientRow.js

@@ -0,0 +1,73 @@
+/* @flow */
+
+import closest from 'closest-ng';
+import Kefir from 'kefir';
+import kefirStopper from 'kefir-stopper';
+
+import type InboxComposeView from './views/inbox-compose-view';
+
+type Options = {
+  labelText?: ?string,
+  el?: ?HTMLElement,
+};
+
+const createRowElement = ({ labelText, el }: Options): HTMLElement => {
+  const row = document.createElement('div');
+  const label = document.createElement('span');
+  const content = document.createElement('div');
+
+  row.classList.add('inboxsdk__recipient_row');
+  label.classList.add('inboxsdk__recipient_label');
+  content.classList.add('inboxsdk__recipient_content');
+
+  if (labelText) {
+    label.textContent = labelText;
+    row.appendChild(label);
+  }
+
+  if (el) {
+    content.appendChild(el);
+    row.appendChild(content);
+  }
+
+  return row;
+};
+
+export default function addRecipientRow(
+  inboxComposeView: InboxComposeView,
+  recipientRowOptionStream: Kefir.Observable<?Options>
+): () => void {
+  let row: ?HTMLElement = null;
+
+  const insertionPoint = inboxComposeView.getBCCRow();
+  const destroyStopper = kefirStopper();
+
+  recipientRowOptionStream
+    .takeUntilBy(inboxComposeView.getStopper())
+    .takeUntilBy(destroyStopper)
+    .onValue((options) => {
+      if (row) {
+        row.remove();
+        row = null;
+      }
+
+      if (options) {
+        row = createRowElement(options);
+        insertionPoint.insertAdjacentElement('afterend', row);
+      }
+    });
+
+  destroyStopper
+    .merge(inboxComposeView.getStopper())
+    .take(1)
+    .onValue(() => {
+      if (row) {
+        row.remove();
+        row = null;
+      }
+    });
+
+  return () => {
+    destroyStopper.destroy();
+  };
+}

package/src/platform-implementation-js/dom-driver/inbox/createLink.js

@@ -0,0 +1,21 @@
+/* @flow */
+
+import includes from 'lodash/includes';
+import type InboxDriver from './inbox-driver';
+import populateRouteID from '../../lib/populateRouteID';
+import type { RouteParams } from '../../namespaces/router';
+import { NATIVE_ROUTE_IDS } from '../../constants/router';
+
+export default function createLink(
+  driver: InboxDriver,
+  routeID: string,
+  params: ?RouteParams
+): string {
+  if (includes(Object.values(NATIVE_ROUTE_IDS), routeID)) {
+    throw new Error('NativeRouteIDs are not currently supported in Inbox');
+  }
+  if (!driver.getCustomRouteIDs().has(routeID)) {
+    throw new Error(`Invalid routeID: ${routeID}`);
+  }
+  return '#' + populateRouteID(routeID, params);
+}

package/src/platform-implementation-js/dom-driver/inbox/createLink.test.js

@@ -0,0 +1,30 @@
+/* @flow */
+
+import createLink from './createLink';
+
+function makeDriver(): any {
+  const customRouteIDs = new Set();
+  return {
+    getCustomRouteIDs: () => customRouteIDs,
+  };
+}
+
+test('works for custom view', () => {
+  const driver = makeDriver();
+  driver.getCustomRouteIDs().add('example/:bar');
+  expect(createLink(driver, 'example/:bar', { bar: 'foo' })).toBe(
+    '#example/foo'
+  );
+});
+
+test('fails for unknown route id', () => {
+  expect(() =>
+    createLink(makeDriver(), 'example/:bar', { bar: 'foo' })
+  ).toThrowError('Invalid routeID: example/:bar');
+});
+
+test('fails for native route ids', () => {
+  expect(() =>
+    createLink(makeDriver(), 'inbox/:threadID', { threadID: 'abc' })
+  ).toThrowError('NativeRouteIDs are not currently supported in Inbox');
+});

package/src/platform-implementation-js/dom-driver/inbox/custom-style.js

@@ -0,0 +1,22 @@
+/* @flow */
+
+import type Kefir from 'kefir';
+import udKefir from 'ud-kefir';
+import rewriteCssWithIdMap from '../../lib/rewriteCssWithIdMap';
+var fs = require('fs');
+var cssContent: Kefir.Observable<string> = udKefir(
+  module,
+  fs.readFileSync(__dirname + '/../../style/inbox.css', 'utf8')
+);
+
+export default function customStyle(root: Document = document) {
+  if (!root.getElementById('inboxsdk__style')) {
+    const style = root.createElement('style');
+    style.id = 'inboxsdk__style';
+    cssContent.onValue((css) => {
+      style.textContent = rewriteCssWithIdMap(css);
+    });
+    if (!root.head) throw new Error('missing head');
+    root.head.appendChild(style);
+  }
+}

package/src/platform-implementation-js/dom-driver/inbox/detection/appToolbarLocation/parser.js

@@ -0,0 +1,49 @@
+/* @flow */
+
+import ErrorCollector from '../../../../lib/ErrorCollector';
+import querySelectorOne from '../../../../lib/dom/querySelectorOne';
+
+export default function parser(el: HTMLElement) {
+  const ec = new ErrorCollector('appToolbarLocation');
+
+  ec.run('children check', () => {
+    if (el.childElementCount < 2) {
+      throw new Error('expected more children');
+    }
+  });
+
+  ec.run('position check', () => {
+    const rect = el.getBoundingClientRect();
+    if (rect.top > 100) {
+      throw new Error('expected element to border top of screen');
+    }
+    if (window.innerWidth - rect.right > 100) {
+      throw new Error('expected element to border right side of screen');
+    }
+    if (rect.width > 500) {
+      throw new Error('expected element to span only the right of the screen');
+    }
+    if (rect.height > 150) {
+      throw new Error('expected element to span only the right of the screen');
+    }
+  });
+
+  const chatSidebarButton = ec.run('chatSidebarButton', () =>
+    querySelectorOne(
+      el,
+      'div[role=button][jsaction*="global.toggle_chat_roster"]'
+    )
+  );
+
+  const score = 1 - ec.errorCount() / ec.runCount();
+  return {
+    elements: {
+      chatSidebarButton,
+    },
+    score,
+    errors: ec.getErrorLogs(),
+  };
+}
+
+/*:: const x = parser(({}:any)); */
+export type Parsed = typeof x;

package/src/platform-implementation-js/dom-driver/inbox/detection/attachmentCard/parser.js

@@ -0,0 +1,33 @@
+/* @flow */
+
+import ErrorCollector from '../../../../lib/ErrorCollector';
+import querySelectorOne from '../../../../lib/dom/querySelectorOne';
+import BigNumber from 'bignumber.js';
+
+export default function parser(el: HTMLElement) {
+  const ec = new ErrorCollector('attachmentCard');
+
+  ec.run('tabindex', () => {
+    if (!el.hasAttribute('tabindex')) throw new Error('expected tabindex');
+  });
+
+  // Very different cards like those for youtube links aren't detected by the
+  // watcher/finder. Google drive cards aren't distinguishable from attachment
+  // cards in the html, so we just expose them as FILE cards. The only issue
+  // for applications is that cardView.addButton() is a no-op on drive cards.
+  const type = 'FILE';
+
+  const elements = {};
+  const score = 1 - ec.errorCount() / ec.runCount();
+  return {
+    elements,
+    attributes: {
+      type,
+    },
+    score,
+    errors: ec.getErrorLogs(),
+  };
+}
+
+/*:: const x = parser(({}:any)); */
+export type Parsed = typeof x;

package/src/platform-implementation-js/dom-driver/inbox/detection/attachmentOverlay/parser.js

@@ -0,0 +1,85 @@
+/* @flow */
+
+import t from 'transducers.js';
+import ErrorCollector from '../../../../lib/ErrorCollector';
+import querySelectorOne from '../../../../lib/dom/querySelectorOne';
+
+import { defn } from 'ud';
+
+function parser(el: HTMLElement) {
+  const ec = new ErrorCollector('attachmentOverlay');
+
+  ec.run('tabindex', () => {
+    if (!el.hasAttribute('tabindex')) throw new Error('expected tabindex');
+  });
+
+  const downloadButton: ?HTMLElement = ec.run('downloadButton', () => {
+    const candidate: ?HTMLElement = t.toArray(
+      Array.prototype.slice.call(
+        el.querySelectorAll(
+          'div[role=button][tabindex][data-tooltip]:not([aria-disabled=true]):not([aria-pressed]):not([aria-expanded])'
+        )
+      ),
+      t.compose(
+        t.filter(
+          (el) =>
+            el.childElementCount === 1 &&
+            el.firstElementChild.childElementCount === 0
+        ),
+        t.filter((el) => {
+          if (global.document) {
+            const rect = el.getBoundingClientRect();
+            if (rect.top > 100) return false;
+            return true;
+          } else {
+            // Can't use screen position logic in unit tests so we're cheating a
+            // little and depending on an exact class name.
+            return el.parentElement.classList.contains(
+              'ndfHFb-c4YZDc-Wrql6b-C7uZwb-b0t70b'
+            );
+          }
+        }),
+        t.filter((el) => {
+          const elIx = Array.prototype.indexOf.call(
+            el.parentElement.children,
+            el
+          );
+          const nextDivSibling = Array.prototype.filter.call(
+            el.parentElement.children,
+            (el, i) => i > elIx && el.nodeName === 'DIV'
+          )[0];
+          return (
+            nextDivSibling &&
+            nextDivSibling.getAttribute('aria-haspopup') === 'true'
+          );
+        }),
+        t.take(1)
+      )
+    )[0];
+    if (!candidate) throw new Error('Failed to find element');
+    if (candidate.getAttribute('aria-label') === 'Print')
+      throw new Error('Found print button instead');
+    return candidate;
+  });
+
+  const buttonContainer: ?HTMLElement = downloadButton
+    ? (downloadButton: any).parentElement
+    : null;
+
+  const elements = {
+    downloadButton,
+    buttonContainer,
+  };
+  const score = 1 - ec.errorCount() / ec.runCount();
+  return {
+    elements,
+    attributes: {},
+    score,
+    errors: ec.getErrorLogs(),
+  };
+}
+
+/*:: const x = parser(({}:any)); */
+export type Parsed = typeof x;
+
+export default defn(module, parser);

package/src/platform-implementation-js/dom-driver/inbox/detection/chatSidebar/parser.js

@@ -0,0 +1,33 @@
+/* @flow */
+
+import ErrorCollector from '../../../../lib/ErrorCollector';
+import querySelectorOne from '../../../../lib/dom/querySelectorOne';
+
+import { defn } from 'ud';
+
+function parser(el: HTMLElement) {
+  const ec = new ErrorCollector('chatSidebar');
+
+  ec.run('position:fixed', () => {
+    if (getComputedStyle((el: any).parentElement).position !== 'fixed')
+      throw new Error('expected position:fixed in parent');
+  });
+
+  ec.run('id', () => {
+    if (!el.id) throw new Error('expected id');
+  });
+
+  const elements = {};
+  const score = 1 - ec.errorCount() / ec.runCount();
+  return {
+    elements,
+    attributes: {},
+    score,
+    errors: ec.getErrorLogs(),
+  };
+}
+
+/*:: const x = parser(({}:any)); */
+export type Parsed = typeof x;
+
+export default defn(module, parser);

package/src/platform-implementation-js/dom-driver/inbox/detection/compose/parser.js

@@ -0,0 +1,220 @@
+/* @flow */
+
+import ErrorCollector from '../../../../lib/ErrorCollector';
+import querySelectorOne from '../../../../lib/dom/querySelectorOne';
+import closest from 'closest-ng';
+
+import { defn } from 'ud';
+
+function parser(el: HTMLElement) {
+  const ec = new ErrorCollector('compose');
+
+  const isInline = el.getAttribute('role') !== 'dialog';
+
+  const sendBtn = ec.run('send button', () =>
+    querySelectorOne(
+      el,
+      'div[jstcache] > div[role=button][jsaction$=".send"], ' +
+        'div[jstcache] > div[role=button][disabled]:not([title]):not([data-tooltip])'
+    )
+  );
+  const attachBtn = ec.run('attach button', () =>
+    querySelectorOne(el, 'div[role=button][jsaction$=".attach"]')
+  );
+  const body = ec.run('body', () =>
+    querySelectorOne(
+      el,
+      'div[contenteditable][g_editable], div[id][tabindex][aria-label][jsaction*=".quick_compose_handle_input"]'
+    )
+  );
+  const subject = isInline
+    ? null
+    : ec.run('subject', () => {
+        const subject = querySelectorOne(
+          el,
+          'div[jstcache][jsan] > div > input[type=text][title][placeholder][jsaction*="input:"]'
+        );
+        if (!(subject instanceof HTMLInputElement))
+          throw new Error('Wrong type');
+        return subject;
+      });
+  const popOutBtn = isInline
+    ? ec.run('pop-out button', () =>
+        querySelectorOne(el, 'button[jsaction$=".quick_compose_popout_mole"]')
+      )
+    : null;
+
+  const discardBtn = ec.run('discard button', () =>
+    querySelectorOne(el, 'button[jsaction$=".discard_draft"]')
+  );
+
+  const titleBar = isInline
+    ? null
+    : ec.run('title bar', () =>
+        querySelectorOne(el, 'div[jsaction$=".focus_mole"]')
+      );
+
+  const toggleFullscreenButton = isInline
+    ? null
+    : ec.run('fullscreen button', () =>
+        querySelectorOne(el, 'button[jsaction$=".toggle_full_screen"]')
+      );
+  const toggleFullscreenButtonImage = isInline
+    ? null
+    : ec.run(
+        'fullscreen button image',
+        () =>
+          ((querySelectorOne(
+            el,
+            'button[jsaction$=".toggle_full_screen"] img'
+          ): any): HTMLImageElement)
+      );
+  const closeBtn = isInline
+    ? null
+    : ec.run('close button', () =>
+        querySelectorOne(
+          el,
+          'div[jstcache][jsan][jsaction] > button[jsaction$=".close_mole"]'
+        )
+      );
+  const minimizeBtn = isInline
+    ? null
+    : ec.run('minimize button', () =>
+        querySelectorOne(
+          el,
+          'div[jstcache][jsan][jsaction] > button[jsaction$=".minimize_mole"]'
+        )
+      );
+  const minimizeBtnImage = isInline
+    ? null
+    : ec.run(
+        'minimize button image',
+        () =>
+          ((querySelectorOne(
+            el,
+            'div[jstcache][jsan][jsaction] > button[jsaction$=".minimize_mole"] img'
+          ): any): HTMLImageElement)
+      );
+  const bodyPlaceholder = isInline
+    ? null
+    : ec.run('body placeholder', () => {
+        const el = body && body.previousElementSibling;
+        if (!(el instanceof HTMLElement) || el.nodeName !== 'LABEL')
+          throw new Error(
+            `compose body placeholder wrong type ${
+              el ? el.nodeName : 'undefined'
+            }`
+          );
+        return el;
+      });
+
+  const fromPicker: ?HTMLElement = el.querySelector(
+    'div[role=button][jsaction*=toggle_custom_from_menu]'
+  );
+  const fromPickerEmailSpan = fromPicker
+    ? ec.run('from picker email span', () =>
+        querySelectorOne(fromPicker, 'span')
+      )
+    : null;
+
+  const recipientFields = isInline
+    ? null
+    : ec.run('recipient fields', () => {
+        const recipientFields: HTMLInputElement[] = (el.querySelectorAll(
+          'input[type=text][role=combobox]'
+        ): any);
+        if (recipientFields.length != 3)
+          throw new Error(
+            `Found ${recipientFields.length} recipient fields, expected 3`
+          );
+        return recipientFields;
+      });
+  const [toInput, ccInput, bccInput] = recipientFields || [];
+
+  const toggleCcBccButton = isInline
+    ? null
+    : ec.run('toggle cc/bcc button', () =>
+        querySelectorOne(el, 'button[jsaction*=".toggle_cc_bcc"]')
+      );
+
+  const toRow = isInline
+    ? null
+    : ec.run('to row', () => {
+        if (!toInput) throw new Error('Could not locate To input');
+
+        const toInputAncestor = closest(
+          toInput,
+          'div > button[jsaction$=".toggle_cc_bcc"] + div'
+        );
+        const toRow = toInputAncestor && toInputAncestor.parentElement;
+        if (!(toRow instanceof HTMLElement))
+          throw new Error('Could not locate To row');
+
+        return toRow;
+      });
+
+  const ccRow = isInline
+    ? null
+    : ec.run('cc row', () => {
+        if (!ccInput) throw new Error('Could not locate CC input');
+
+        const ccInputAncestor = closest(ccInput, 'div[class] > label + div');
+        const ccRow = ccInputAncestor && ccInputAncestor.parentElement;
+        if (!(ccRow instanceof HTMLElement))
+          throw new Error('Could not locate CC row');
+
+        return ccRow;
+      });
+
+  const bccRow = isInline
+    ? null
+    : ec.run('bcc row', () => {
+        if (!bccInput) throw new Error('Could not locate BCC input');
+
+        const bccInputAncestor = closest(bccInput, 'div[class] > label + div');
+        const bccRow = bccInputAncestor && bccInputAncestor.parentElement;
+        if (!(bccRow instanceof HTMLElement))
+          throw new Error('Could not locate BCC row');
+
+        return bccRow;
+      });
+
+  const elements = {
+    sendBtn,
+    attachBtn,
+    body,
+    subject,
+    popOutBtn,
+    discardBtn,
+    titleBar,
+    toggleFullscreenButton,
+    toggleFullscreenButtonImage,
+    closeBtn,
+    minimizeBtn,
+    minimizeBtnImage,
+    bodyPlaceholder,
+    fromPicker,
+    fromPickerEmailSpan,
+    toInput,
+    ccInput,
+    bccInput,
+    toRow,
+    ccRow,
+    bccRow,
+    toggleCcBccButton,
+  };
+  const score = 1 - ec.errorCount() / ec.runCount();
+  return {
+    elements,
+    attributes: {
+      isInline,
+    },
+    score,
+    errors: ec.getErrorLogs(),
+  };
+}
+
+/*:: const x = parser(({}:any)); */
+export type Parsed = typeof x;
+
+export default defn(module, parser);

package/src/platform-implementation-js/dom-driver/inbox/detection/message/parser.js

@@ -0,0 +1,97 @@
+/* @flow */
+
+import last from 'lodash/last';
+import ErrorCollector from '../../../../lib/ErrorCollector';
+import querySelectorOne from '../../../../lib/dom/querySelectorOne';
+
+export default function parser(el: HTMLElement) {
+  const ec = new ErrorCollector('compose');
+
+  ec.run('tabindex', () => {
+    if (!el.hasAttribute('tabindex')) throw new Error('expected tabindex');
+  });
+
+  const inboxMessageId: ?string = ec.run('message id', () => {
+    const m = /msg-[^:]+:[^:\d]*\d+/.exec(el.getAttribute('data-msg-id') || '');
+    if (!m) {
+      throw new Error('message id regex failed');
+    }
+    return m[0];
+  });
+
+  const heading = ec.run('heading', () => {
+    const heading = el.querySelector('div[role=heading]');
+    if (!heading) throw new Error('failed to find heading');
+    return heading;
+  });
+
+  // Super-collapsed/HIDDEN messages don't have a body.
+  const body: ?HTMLElement = el.querySelector(
+    'div[role=heading] ~ div:not(:empty)'
+  );
+
+  // The last message in a thread is always loaded and doesn't have the toggle
+  // collapse button.
+  const toggleCollapse: ?HTMLElement = el.querySelector(
+    'div[jsaction$=".message_toggle_collapse"]'
+  );
+
+  const loaded =
+    body != null &&
+    (toggleCollapse == null ||
+      toggleCollapse.getAttribute('role') === 'heading');
+
+  const viewState = loaded ? 'EXPANDED' : body != null ? 'COLLAPSED' : 'HIDDEN';
+
+  const isDraft = loaded && heading && !heading.querySelector('span[email]');
+
+  const sender =
+    isDraft || !heading || !body
+      ? null
+      : ec.run('sender', () =>
+          querySelectorOne(heading, '[email]:first-child')
+        );
+
+  const recipientElements = isDraft
+    ? null
+    : el.querySelectorAll(
+        '[role=heading] [email]:not(:first-child), [role=heading] + div [email]'
+      );
+
+  const attachmentsArea: ?HTMLElement =
+    isDraft || !body || viewState !== 'EXPANDED'
+      ? null
+      : ec.run('attachments area', () => {
+          const lastSection = last(
+            (body.parentElement: any).querySelectorAll('section:last-child')
+          );
+          if (!lastSection) {
+            throw new Error('element not found');
+          }
+          return lastSection;
+        });
+
+  const elements = {
+    heading,
+    body,
+    sender,
+    toggleCollapse,
+    attachmentsArea,
+  };
+  const score = 1 - ec.errorCount() / ec.runCount();
+  return {
+    elements,
+    attributes: {
+      loaded,
+      viewState,
+      inboxMessageId,
+      recipientElements,
+      isDraft,
+    },
+    score,
+    errors: ec.getErrorLogs(),
+  };
+}
+
+/*:: const x = parser(({}:any)); */
+export type Parsed = typeof x;

package/src/platform-implementation-js/dom-driver/inbox/detection/nativeDrawer/parser.js

@@ -0,0 +1,30 @@
+/* @flow */
+
+import ErrorCollector from '../../../../lib/ErrorCollector';
+import querySelectorOne from '../../../../lib/dom/querySelectorOne';
+
+export default function parser(el: HTMLElement) {
+  const errors: any[] = [];
+  if (el.childElementCount < 2) {
+    errors.push('expected more children');
+  }
+  const rect = el.getBoundingClientRect();
+  if (rect.top > 100) {
+    errors.push('expected element to border top of screen');
+  }
+  if (window.innerWidth - rect.right > 100) {
+    errors.push('expected element to border right side of screen');
+  }
+  if (window.innerHeight - rect.bottom > 100) {
+    errors.push('expected element to border bottom side of screen');
+  }
+
+  return {
+    elements: {},
+    score: errors.length === 0 ? 1 : 0,
+    errors,
+  };
+}
+
+/*:: const x = parser(({}:any)); */
+export type Parsed = typeof x;