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

package/src/platform-implementation-js/views/conversations/thread-view.js

@@ -0,0 +1,156 @@
+/* @flow */
+
+import { defn, defonce } from 'ud';
+import EventEmitter from '../../lib/safe-event-emitter';
+import type Membrane from '../../lib/Membrane';
+import type SimpleElementView from '../../views/SimpleElementView';
+import kefirCast from 'kefir-cast';
+import Kefir from 'kefir';
+import ContentPanelView from '../content-panel-view';
+import get from '../../../common/get-or-fail';
+import type MessageView from './message-view';
+import type { Driver, ThreadViewDriver } from '../../driver-interfaces/driver';
+
+import type CustomMessageView, {
+  CustomMessageDescriptor,
+} from '../../views/conversations/custom-message-view';
+
+const memberMap = defonce(module, () => new WeakMap());
+
+// documented in src/docs/
+class ThreadView extends EventEmitter {
+  destroyed: boolean = false;
+
+  constructor(
+    threadViewImplementation: ThreadViewDriver,
+    appId: string,
+    driver: Driver,
+    membrane: Membrane
+  ) {
+    super();
+
+    const members = { threadViewImplementation, appId, driver, membrane };
+    memberMap.set(this, members);
+
+    _bindToStreamEvents(this, threadViewImplementation);
+  }
+
+  addSidebarContentPanel(descriptor: Object): ?ContentPanelView {
+    const descriptorPropertyStream = kefirCast(
+      (Kefir: any),
+      descriptor
+    ).toProperty();
+    const members = get(memberMap, this);
+
+    members.driver
+      .getLogger()
+      .eventSdkPassive('threadView.addSidebarContentPanel');
+
+    const contentPanelImplementation =
+      members.threadViewImplementation.addSidebarContentPanel(
+        descriptorPropertyStream
+      );
+    if (contentPanelImplementation) {
+      return new ContentPanelView(contentPanelImplementation);
+    }
+
+    return null;
+  }
+
+  addNoticeBar(): SimpleElementView {
+    const members = get(memberMap, this);
+    return members.threadViewImplementation.addNoticeBar();
+  }
+
+  registerHiddenCustomMessageNoticeProvider(
+    provider: (
+      numberCustomMessagesHidden: number,
+      numberNativeMessagesHidden: ?number,
+      unmountPromise: Promise<void>
+    ) => HTMLElement
+  ) {
+    const members = get(memberMap, this);
+    return members.threadViewImplementation.registerHiddenCustomMessageNoticeProvider(
+      provider
+    );
+  }
+
+  addCustomMessage(descriptor: Object): CustomMessageView {
+    const descriptorPropertyStream = kefirCast(
+      (Kefir: any),
+      descriptor
+    ).toProperty();
+    const members = get(memberMap, this);
+
+    members.driver.getLogger().eventSdkPassive('threadView.addCustomMessage');
+
+    return members.threadViewImplementation.addCustomMessage(
+      descriptorPropertyStream
+    );
+  }
+
+  getMessageViews(): Array<MessageView> {
+    const { threadViewImplementation, membrane } = get(memberMap, this);
+
+    return threadViewImplementation
+      .getMessageViewDrivers()
+      .filter((messageViewDriver) => messageViewDriver.isLoaded())
+      .map((messageViewDriver) => membrane.get(messageViewDriver));
+  }
+
+  getMessageViewsAll(): Array<MessageView> {
+    const { threadViewImplementation, membrane } = get(memberMap, this);
+
+    return threadViewImplementation
+      .getMessageViewDrivers()
+      .map((messageViewDriver) => membrane.get(messageViewDriver));
+  }
+
+  getSubject(): string {
+    return get(memberMap, this).threadViewImplementation.getSubject();
+  }
+
+  getThreadID(): string {
+    get(memberMap, this)
+      .driver.getLogger()
+      .deprecationWarning(
+        'threadView.getThreadID',
+        'threadView.getThreadIDAsync'
+      );
+    return get(memberMap, this).threadViewImplementation.getThreadID();
+  }
+
+  getThreadIDAsync(): Promise<string> {
+    return get(memberMap, this).threadViewImplementation.getThreadIDAsync();
+  }
+
+  addLabel(): SimpleElementView {
+    return get(memberMap, this).threadViewImplementation.addLabel();
+  }
+}
+
+export default defn(module, ThreadView);
+
+function _bindToStreamEvents(threadView, threadViewImplementation) {
+  threadViewImplementation.getEventStream().onEnd(function () {
+    threadView.destroyed = true;
+    threadView.emit('destroy');
+
+    threadView.removeAllListeners();
+  });
+
+  threadViewImplementation
+    .getEventStream()
+    .filter(function (event) {
+      return event.type !== 'internal' && event.eventName === 'contactHover';
+    })
+    .onValue(function (event) {
+      const { membrane } = get(memberMap, threadView);
+      threadView.emit(event.eventName, {
+        contactType: event.contactType,
+        messageView: membrane.get(event.messageViewDriver),
+        contact: event.contact,
+        threadView: threadView,
+      });
+    });
+}

package/src/platform-implementation-js/views/keyboard-shortcut-handle.d.ts

@@ -5,3 +5,4 @@ export default class KeyboardShortcutHandle extends EventEmitter {
     constructor(chord: string, description: string);
     remove(): void;
 }
+//# sourceMappingURL=keyboard-shortcut-handle.d.ts.map

package/src/platform-implementation-js/views/keyboard-shortcut-handle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"keyboard-shortcut-handle.d.ts","sourceRoot":"","sources":["../../../../../src/platform-implementation-js/views/keyboard-shortcut-handle.ts"],"names":[],"mappings":"AAAA,OAAO,YAAY,MAAM,2BAA2B,CAAC;AAGrD,MAAM,CAAC,OAAO,OAAO,sBAAuB,SAAQ,YAAY;IACvD,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;gBAER,KAAK,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM;IAM9C,MAAM;CAGd"}

package/src/platform-implementation-js/views/native-nav-item-view.js

@@ -0,0 +1,98 @@
+/* @flow */
+
+import EventEmitter from '../lib/safe-event-emitter';
+import Kefir from 'kefir';
+import kefirCast from 'kefir-cast';
+import defer from '../../common/defer';
+import get from '../../common/get-or-fail';
+import NavItemView from './nav-item-view';
+
+import type { Driver } from '../driver-interfaces/driver';
+import type GmailNavItemView from '../dom-driver/gmail/views/gmail-nav-item-view';
+
+const memberMap = new WeakMap();
+
+export default class NativeNavItemView extends EventEmitter {
+  constructor(
+    appId: string,
+    driver: Driver,
+    labelName: string,
+    navItemViewDriverPromise: Promise<GmailNavItemView>
+  ) {
+    super();
+
+    const members = {
+      appId,
+      driver,
+      labelName,
+      navItemViews: [],
+      navItemViewDriver: (null: ?GmailNavItemView),
+      navItemViewDriverPromise,
+    };
+    memberMap.set(this, members);
+
+    navItemViewDriverPromise.then((navItemViewDriver) => {
+      if (!navItemViewDriver) {
+        return;
+      }
+      members.navItemViewDriver = navItemViewDriver;
+      navItemViewDriver
+        .getEventStream()
+        .onValue((event) => _handleStreamEvent(this, event));
+    });
+  }
+
+  addNavItem(navItemDescriptor: Object): NavItemView {
+    const members = get(memberMap, this);
+
+    const navItemDescriptorPropertyStream = kefirCast(
+      (Kefir: any),
+      navItemDescriptor
+    ).toProperty();
+    const childNavItemView = new NavItemView(
+      members.appId,
+      members.driver,
+      navItemDescriptorPropertyStream,
+      members.navItemViewDriverPromise.then((navItemViewDriver) => {
+        const childNavItemViewDriver = navItemViewDriver.addNavItem(
+          members.appId,
+          navItemDescriptorPropertyStream
+        );
+        return childNavItemViewDriver;
+      })
+    );
+
+    members.navItemViews.push(childNavItemView);
+    return childNavItemView;
+  }
+
+  isCollapsed(): boolean {
+    return (
+      localStorage.getItem(
+        'inboxsdk__nativeNavItem__state_' + get(memberMap, this).labelName
+      ) === 'collapsed'
+    );
+  }
+
+  setCollapsed(collapseValue: boolean) {
+    const members = get(memberMap, this);
+
+    if (members.navItemViewDriver) {
+      members.navItemViewDriver.setCollapsed(collapseValue);
+    } else {
+      localStorage.setItem(
+        'inboxsdk__nativeNavItem__state_' + members.labelName,
+        collapseValue ? 'collapsed' : 'expanded'
+      );
+    }
+  }
+}
+
+function _handleStreamEvent(emitter, event) {
+  switch (event.eventName) {
+    case 'expanded':
+    case 'collapsed':
+      emitter.emit(event.eventName);
+      break;
+  }
+}

package/src/platform-implementation-js/views/nav-item-view.d.ts

@@ -0,0 +1,24 @@
+import * as Kefir from 'kefir';
+import EventEmitter from 'events';
+import { NavItemDescriptor } from '../../inboxsdk';
+import GmailNavItemView from '../dom-driver/gmail/views/gmail-nav-item-view';
+import { Driver } from '../driver-interfaces/driver';
+
+export default class NavItemView extends EventEmitter {
+  constructor(
+    appId: string,
+    driver: Driver,
+    navItemDescriptorPropertyStream: Kefir.Observable<any, any>,
+    gmailNavItemView: Promise<GmailNavItemView>
+  );
+
+  addNavItem(
+    descriptor:
+      | NavItemDescriptor
+      | Kefir.Observable<NavItemDescriptor | null, unknown>
+  ): NavItemView;
+  remove(): void;
+  setCollapsed(collapseState: boolean): void;
+  isCollapsed(): boolean;
+  destroyed: boolean;
+}

package/src/platform-implementation-js/views/nav-item-view.js

@@ -0,0 +1,191 @@
+/* @flow */
+
+import isEqual from 'lodash/isEqual';
+import Kefir from 'kefir';
+import kefirCast from 'kefir-cast';
+import defer from '../../common/defer';
+import get from '../../common/get-or-fail';
+import EventEmitter from '../lib/safe-event-emitter';
+
+import NAV_ITEM_TYPES from '../constants/nav-item-types';
+
+import type { Driver } from '../driver-interfaces/driver';
+import type GmailNavItemView from '../dom-driver/gmail/views/gmail-nav-item-view';
+
+const memberMap = new WeakMap();
+
+// documented in src/docs/
+
+export default class NavItemView extends EventEmitter {
+  destroyed: boolean = false;
+
+  constructor(
+    appId: string,
+    driver: Driver,
+    navItemDescriptorPropertyStream: Object,
+    navItemViewDriverPromise: Promise<GmailNavItemView>
+  ) {
+    super();
+
+    const members = {
+      appId,
+      driver,
+      navItemDescriptorPropertyStream,
+      navItemViews: [],
+      navItemViewDriver: (null: ?GmailNavItemView),
+      navItemViewDriverPromise,
+    };
+    memberMap.set(this, members);
+
+    driver.getStopper().onValue(this.remove.bind(this));
+
+    navItemViewDriverPromise.then((navItemViewDriver) => {
+      if (this.destroyed || !navItemViewDriver) {
+        return; //we have been removed already
+      }
+      const driver = members.driver;
+      members.navItemViewDriver = navItemViewDriver;
+
+      members.navItemDescriptorPropertyStream
+        .sampledBy(navItemViewDriver.getEventStream(), (a, b) => [a, b])
+        .onValue((navItemDescriptor) =>
+          _handleViewDriverStreamEvent(
+            this,
+            navItemViewDriver,
+            driver,
+            navItemDescriptor
+          )
+        );
+
+      Kefir.combine([
+        members.navItemDescriptorPropertyStream,
+        driver.getRouteViewDriverStream(),
+      ])
+        .takeUntilBy(
+          navItemViewDriver
+            .getEventStream()
+            .filter(() => false)
+            .beforeEnd(() => null)
+        )
+        .onValue((x) => {
+          _handleRouteViewChange(navItemViewDriver, x);
+        });
+    });
+  }
+
+  addNavItem(navItemDescriptor: Object): NavItemView {
+    if (this.destroyed) throw new Error('this nav item view does not exist');
+
+    const members = get(memberMap, this);
+    const driver = members.driver;
+    const appId = members.appId;
+    const navItemViews = members.navItemViews;
+
+    const navItemDescriptorPropertyStream = kefirCast(
+      Kefir,
+      navItemDescriptor
+    ).toProperty();
+    const childNavItemView = new NavItemView(
+      appId,
+      driver,
+      navItemDescriptorPropertyStream,
+      members.navItemViewDriverPromise.then((navItemViewDriver) => {
+        const childNavItemViewDriver = navItemViewDriver.addNavItem(
+          members.appId,
+          navItemDescriptorPropertyStream
+        );
+        return childNavItemViewDriver;
+      })
+    );
+
+    navItemViews.push(childNavItemView);
+    return childNavItemView;
+  }
+
+  remove() {
+    if (this.destroyed) {
+      return;
+    }
+    const members = get(memberMap, this);
+    const { navItemViews } = members;
+
+    this.destroyed = true;
+    this.emit('destroy');
+
+    navItemViews.forEach(function (navItemView) {
+      navItemView.remove();
+    });
+
+    members.navItemViewDriverPromise.then((navItemViewDriver) => {
+      navItemViewDriver.destroy();
+    });
+  }
+
+  isCollapsed(): boolean {
+    const members = get(memberMap, this);
+    const navItemViewDriver = members.navItemViewDriver;
+
+    if (navItemViewDriver) {
+      return navItemViewDriver.isCollapsed();
+    } else {
+      return false;
+    }
+  }
+
+  setCollapsed(collapseValue: boolean) {
+    get(memberMap, this).navItemViewDriverPromise.then((navItemViewDriver) => {
+      navItemViewDriver.setCollapsed(collapseValue);
+    });
+  }
+}
+
+function _handleViewDriverStreamEvent(
+  eventEmitter,
+  navItemViewDriver,
+  driver,
+  [navItemDescriptor, event]
+) {
+  switch (event.eventName) {
+    case 'click':
+      // When in Gmailv2, we ignore the onClick, routeID, and routeParams options on GROUPER nav-items
+      if (navItemDescriptor.type === NAV_ITEM_TYPES.GROUPER) return;
+
+      if (typeof navItemDescriptor.onClick === 'function') {
+        let defaultPrevented = false;
+        const syntheticEvent = {
+          preventDefault() {
+            defaultPrevented = true;
+          },
+        };
+
+        navItemDescriptor.onClick(syntheticEvent);
+
+        if (defaultPrevented) {
+          break;
+        }
+      }
+
+      if (navItemDescriptor.routeID) {
+        driver.goto(navItemDescriptor.routeID, navItemDescriptor.routeParams);
+      } else {
+        navItemViewDriver.toggleCollapse();
+      }
+
+      break;
+    case 'expanded':
+    case 'collapsed':
+      eventEmitter.emit(event.eventName);
+      break;
+  }
+}
+
+function _handleRouteViewChange(
+  navItemViewDriver,
+  [navItemDescriptor, routeViewDriver]
+) {
+  navItemViewDriver.setActive(
+    navItemDescriptor &&
+      routeViewDriver.getRouteID() === navItemDescriptor.routeID &&
+      isEqual(navItemDescriptor.routeParams || {}, routeViewDriver.getParams())
+  );
+}

package/src/platform-implementation-js/views/route-view/custom-route-view.js

@@ -0,0 +1,32 @@
+/* @flow */
+
+import { defn, defonce } from 'ud';
+import RouteView from './route-view';
+import type { RouteViewDriver } from '../../driver-interfaces/route-view-driver';
+import get from '../../../common/get-or-fail';
+
+// documented in src/docs/
+class CustomRouteView extends RouteView {
+  constructor(routeViewDriver: RouteViewDriver) {
+    super(routeViewDriver);
+
+    const members = { routeViewDriver };
+    membersMap.set(this, members);
+  }
+
+  setFullWidth(fullWidth: boolean) {
+    const { routeViewDriver } = get(membersMap, this);
+    routeViewDriver.setFullWidth(fullWidth);
+  }
+
+  getElement(): HTMLElement {
+    const { routeViewDriver } = get(membersMap, this);
+    const el = routeViewDriver.getCustomViewElement();
+    if (!el) throw new Error('Should not happen');
+    return el;
+  }
+}
+
+const membersMap = defonce(module, () => new WeakMap());
+
+export default defn(module, CustomRouteView);

package/src/platform-implementation-js/views/route-view/dummy-route-view-driver.js

@@ -0,0 +1,40 @@
+/* @flow */
+
+import Kefir from 'kefir';
+import kefirBus from 'kefir-bus';
+import kefirStopper from 'kefir-stopper';
+import { defn } from 'ud';
+
+import type { MinRouteViewDriver } from '../../driver-interfaces/route-view-driver';
+
+class DummyRouteViewDriver {
+  _eventStream = kefirBus();
+  _stopper = kefirStopper();
+
+  constructor() {
+    (this: MinRouteViewDriver);
+  }
+
+  getRouteType() {
+    return 'UNKNOWN';
+  }
+  getRouteID() {
+    return 'UNKNOWN';
+  }
+  getParams() {
+    return {};
+  }
+  getEventStream(): Kefir.Observable<Object> {
+    return this._eventStream;
+  }
+  getStopper(): Kefir.Observable<any> {
+    return this._stopper;
+  }
+
+  destroy() {
+    this._eventStream.end();
+    this._stopper.destroy();
+  }
+}
+
+export default defn(module, DummyRouteViewDriver);

package/src/platform-implementation-js/views/route-view/list-route-view.js

@@ -0,0 +1,78 @@
+/* @flow */
+
+import { defn } from 'ud';
+import RouteView from './route-view';
+import Kefir from 'kefir';
+import kefirCast from 'kefir-cast';
+import CollapsibleSectionView from '../collapsible-section-view';
+import SectionView from '../section-view';
+import get from '../../../common/get-or-fail';
+import type { RouteViewDriver } from '../../driver-interfaces/route-view-driver';
+import type { Driver } from '../../driver-interfaces/driver';
+
+// documented in src/docs/
+class ListRouteView extends RouteView {
+  constructor(routeViewDriver: RouteViewDriver, driver: Driver, appId: string) {
+    super(routeViewDriver);
+
+    const members = {
+      routeViewDriver,
+      driver,
+      appId,
+      sectionViews: [],
+    };
+    membersMap.set(this, members);
+
+    _bindToEventStream(routeViewDriver, this);
+  }
+
+  addCollapsibleSection(
+    collapsibleSectionDescriptor: ?Object
+  ): CollapsibleSectionView {
+    const members = get(membersMap, this);
+
+    const collapsibleSectionViewDriver =
+      members.routeViewDriver.addCollapsibleSection(
+        kefirCast((Kefir: any), collapsibleSectionDescriptor).toProperty(),
+        members.appId
+      );
+    const collapsibleSectionView = new CollapsibleSectionView(
+      collapsibleSectionViewDriver,
+      members.driver
+    );
+
+    members.sectionViews.push(collapsibleSectionView);
+    return collapsibleSectionView;
+  }
+
+  addSection(sectionDescriptor: ?Object): SectionView {
+    const members = get(membersMap, this);
+
+    const sectionViewDriver = members.routeViewDriver.addSection(
+      kefirCast((Kefir: any), sectionDescriptor).toProperty(),
+      members.appId
+    );
+    const sectionView = new SectionView(sectionViewDriver, members.driver);
+
+    members.sectionViews.push(sectionView);
+    return sectionView;
+  }
+
+  refresh() {
+    get(membersMap, this).routeViewDriver.refresh();
+  }
+}
+
+const membersMap = new WeakMap();
+
+function _bindToEventStream(routeViewDriver, routeView) {
+  routeViewDriver.getEventStream().onEnd(() => {
+    const members = get(membersMap, routeView);
+
+    members.sectionViews.forEach((sectionView) => {
+      sectionView.destroy();
+    });
+  });
+}
+
+export default defn(module, ListRouteView);

package/src/platform-implementation-js/views/route-view/route-view.js

@@ -0,0 +1,68 @@
+/* @flow */
+
+import EventEmitter from '../../lib/safe-event-emitter';
+import { defn } from 'ud';
+import get from '../../../common/get-or-fail';
+import type { MinRouteViewDriver } from '../../driver-interfaces/route-view-driver';
+
+const membersMap = new WeakMap();
+
+// documented in src/docs/
+class RouteView extends EventEmitter {
+  destroyed: boolean;
+
+  constructor(routeViewDriver: MinRouteViewDriver) {
+    super();
+
+    const members = {
+      routeID: (null: ?string),
+      routeType: (null: ?string),
+      params: (null: ?{ [ix: string]: string }),
+      routeViewDriver,
+    };
+    membersMap.set(this, members);
+
+    this.destroyed = false;
+    _bindToEventStream(routeViewDriver, this);
+  }
+
+  getRouteID(): string {
+    const members = get(membersMap, this);
+
+    if (!members.routeID) {
+      members.routeID = members.routeViewDriver.getRouteID();
+    }
+
+    return members.routeID;
+  }
+
+  getRouteType(): string {
+    const members = get(membersMap, this);
+
+    if (!members.routeType) {
+      members.routeType = members.routeViewDriver.getRouteType();
+    }
+
+    return members.routeType;
+  }
+
+  getParams(): { [ix: string]: string } {
+    const members = get(membersMap, this);
+
+    if (!members.params) {
+      members.params = members.routeViewDriver.getParams();
+    }
+
+    return members.params;
+  }
+}
+
+function _bindToEventStream(routeViewDriver, routeView) {
+  routeViewDriver.getEventStream().onEnd(() => {
+    routeView.destroyed = true;
+    routeView.emit('destroy');
+    routeView.removeAllListeners();
+  });
+}
+
+export default defn(module, RouteView);