@inboxsdk/core 0.2.27 → 0.2.28-alpha.1

package/src/platform-implementation-js/namespaces/global.js

@@ -0,0 +1,51 @@
+/* @flow */
+
+import Kefir from 'kefir';
+import kefirCast from 'kefir-cast';
+
+import ContentPanelView from '../views/content-panel-view';
+import get from '../../common/get-or-fail';
+
+import type { PiOpts } from '../platform-implementation';
+import type Membrane from '../lib/Membrane';
+import type { Driver } from '../driver-interfaces/driver';
+import GmailSupportItemView from '../dom-driver/gmail/views/gmail-support-item-view';
+import type SupportItemDescriptor from '../dom-driver/gmail/views/gmail-support-item-view';
+
+const memberMap = new WeakMap();
+
+export default class Global {
+  constructor(appId: string, driver: Driver, piOpts: PiOpts) {
+    const members = { appId, driver, piOpts };
+    memberMap.set(this, members);
+  }
+
+  async addSidebarContentPanel(descriptor: Object): Promise<?ContentPanelView> {
+    const descriptorPropertyStream = kefirCast(
+      (Kefir: any),
+      descriptor
+    ).toProperty();
+    const members = get(memberMap, this);
+
+    members.driver.getLogger().eventSdkPassive('global.addSidebarContentPanel');
+
+    const contentPanelImplementation =
+      await members.driver.addGlobalSidebarContentPanel(
+        descriptorPropertyStream
+      );
+    if (contentPanelImplementation) {
+      return new ContentPanelView(contentPanelImplementation);
+    }
+
+    return null;
+  }
+
+  addSupportItem(
+    supportItemDescriptor: SupportItemDescriptor
+  ): GmailSupportItemView {
+    const members = get(memberMap, this);
+    members.driver.getLogger().eventSdkPassive('global.addSupportItem');
+
+    return members.driver.addSupportItem(supportItemDescriptor);
+  }
+}

package/src/platform-implementation-js/namespaces/keyboard.js

@@ -0,0 +1,48 @@
+/* @flow */
+/* eslint-disable no-console */
+
+import * as ud from 'ud';
+import get from '../../common/get-or-fail';
+import KeyboardShortcutHandle from '../views/keyboard-shortcut-handle';
+import type { Driver } from '../driver-interfaces/driver';
+
+const memberMap = ud.defonce(module, () => new WeakMap());
+
+// documented in src/docs/
+class Keyboard {
+  constructor(
+    appId: string,
+    appName: ?string,
+    appIconUrl: ?string,
+    driver: Driver
+  ) {
+    const members = { appId, appName, appIconUrl, driver };
+    memberMap.set(this, members);
+  }
+
+  createShortcutHandle(shortcutDescriptor: {
+    chord: string,
+    description: string,
+  }) {
+    const members = get(memberMap, this);
+
+    let { chord, description } = shortcutDescriptor;
+    if (!chord) throw new Error('Keyboard.createShortcutHandle chord missing');
+    if (description == null) {
+      console.error('Keyboard.createShortcutHandle chord missing');
+      description = '';
+    }
+    const keyboardShortcutHandle = new KeyboardShortcutHandle(
+      chord,
+      description
+    );
+    members.driver.activateShortcut(
+      keyboardShortcutHandle,
+      members.appName,
+      members.appIconUrl
+    );
+    return keyboardShortcutHandle;
+  }
+}
+
+export default ud.defn(module, Keyboard);

package/src/platform-implementation-js/namespaces/lists.js

@@ -0,0 +1,58 @@
+/* @flow */
+
+import get from '../../common/get-or-fail';
+import HandlerRegistry from '../lib/handler-registry';
+import ThreadRowView from '../views/thread-row-view';
+import type Membrane from '../lib/Membrane';
+import type { Driver } from '../driver-interfaces/driver';
+
+const memberMap = new WeakMap();
+
+// documented in src/docs/
+export default class Lists {
+  ActionButtonTypes = ActionButtonTypes;
+
+  constructor(appId: string, driver: Driver, membrane: Membrane) {
+    const members = {
+      appId,
+      driver,
+      membrane,
+      threadRowViewRegistry: new HandlerRegistry(),
+    };
+    memberMap.set(this, members);
+
+    driver.getStopper().onValue(() => {
+      members.threadRowViewRegistry.dumpHandlers();
+    });
+
+    members.driver.getThreadRowViewDriverStream().onValue((viewDriver) => {
+      const view = membrane.get(viewDriver);
+      members.threadRowViewRegistry.addTarget(view);
+    });
+  }
+
+  registerThreadRowViewHandler(handler: Function) {
+    return get(memberMap, this).threadRowViewRegistry.registerHandler(handler);
+  }
+
+  getSelectedThreadRowViews() {
+    const members = get(memberMap, this);
+    const threadRowViewDrivers =
+      members.driver.getSelectedThreadRowViewDrivers();
+    const threadRowViews = threadRowViewDrivers.map((d) =>
+      members.membrane.get(d)
+    );
+    return threadRowViews;
+  }
+
+  registerThreadRowViewSelectionHandler(handler: () => any) {
+    const members = get(memberMap, this);
+    return members.driver.registerThreadRowViewSelectionHandler(handler);
+  }
+}
+
+const ActionButtonTypes = Object.freeze({
+  LINK: 'LINK',
+  DROPDOWN: 'DROPDOWN',
+  ACTION: 'ACTION',
+});

package/src/platform-implementation-js/namespaces/modal.js

@@ -0,0 +1,45 @@
+/* @flow */
+
+import { defn, defonce } from 'ud';
+import ModalView from '../widgets/modal-view';
+import get from '../../common/get-or-fail';
+import type { Driver } from '../driver-interfaces/driver';
+import type { PiOpts } from '../platform-implementation';
+
+const memberMap = defonce(module, () => new WeakMap());
+
+// Deprecated, applications should use Widgets instead.
+class Modal {
+  constructor(appId: string, driver: Driver, piOpts: PiOpts) {
+    const members = { appId, driver, piOpts };
+    memberMap.set(this, members);
+  }
+
+  // Deprecated, use Widgets.showModalView
+  show(options: Object): ModalView {
+    const driver = get(memberMap, this).driver;
+    if (get(memberMap, this).piOpts.inboxBeta) {
+      driver
+        .getLogger()
+        .deprecationWarning('Modal.show', 'Widgets.showModalView');
+    }
+    const modalViewDriver = driver.createModalViewDriver(options);
+    const modalView = new ModalView({ driver, modalViewDriver });
+    modalView.show();
+
+    return modalView;
+  }
+
+  // Deprecated, does not have an exact replacement. Use Widgets.showModalView.
+  createModalView(options: Object): ModalView {
+    const driver = get(memberMap, this).driver;
+    driver
+      .getLogger()
+      .deprecationWarning('Modal.createModalView', 'Widgets.showModalView');
+
+    const modalViewDriver = driver.createModalViewDriver(options);
+    return new ModalView({ driver, modalViewDriver });
+  }
+}
+
+export default defn(module, Modal);

package/src/platform-implementation-js/namespaces/nav-menu.js

@@ -0,0 +1,55 @@
+/* @flow */
+
+import Kefir from 'kefir';
+import kefirCast from 'kefir-cast';
+import get from '../../common/get-or-fail';
+import NavItemView from '../views/nav-item-view';
+import NativeNavItemView from '../views/native-nav-item-view';
+
+import type { Driver } from '../driver-interfaces/driver';
+
+import NavItemTypes from '../constants/nav-item-types';
+
+const memberMap = new WeakMap();
+
+export default class NavMenu {
+  NavItemTypes = NavItemTypes;
+  SENT_MAIL: NativeNavItemView;
+
+  constructor(appId: string, driver: Driver) {
+    const members = { appId, driver, navItemViews: [] };
+    memberMap.set(this, members);
+
+    this.SENT_MAIL = _setupSentMail(appId, driver);
+  }
+
+  addNavItem(navItemDescriptor: Object): NavItemView {
+    const members = get(memberMap, this);
+    const navItemDescriptorPropertyStream = kefirCast(
+      Kefir,
+      navItemDescriptor
+    ).toProperty();
+
+    const navItemView = new NavItemView(
+      members.appId,
+      members.driver,
+      navItemDescriptorPropertyStream,
+      members.driver.addNavItem(members.appId, navItemDescriptorPropertyStream)
+    );
+
+    members.navItemViews.push(navItemView);
+    return navItemView;
+  }
+
+  static SENT_MAIL: ?Object = null;
+}
+
+function _setupSentMail(appId, driver) {
+  const nativeNavItemView = new NativeNavItemView(
+    appId,
+    driver,
+    'sent',
+    driver.getSentMailNativeNavItem()
+  );
+  return nativeNavItemView;
+}

package/src/platform-implementation-js/namespaces/router.js

@@ -0,0 +1,217 @@
+/* @flow */
+
+import find from 'lodash/find';
+import intersection from 'lodash/intersection';
+import { defn, defonce } from 'ud';
+
+import HandlerRegistry from '../lib/handler-registry';
+import get from '../../common/get-or-fail';
+import RouteView from '../views/route-view/route-view';
+import ListRouteView from '../views/route-view/list-route-view';
+import CustomRouteView from '../views/route-view/custom-route-view';
+import DummyRouteViewDriver from '../views/route-view/dummy-route-view-driver';
+import type Membrane from '../lib/Membrane';
+import {
+  NATIVE_ROUTE_IDS,
+  NATIVE_LIST_ROUTE_IDS,
+  ROUTE_TYPES,
+} from '../constants/router';
+
+import type { Driver } from '../driver-interfaces/driver';
+import type { Handler } from '../lib/handler-registry';
+
+export type RouteParams = { [ix: string]: string | number };
+
+const memberMap = defonce(module, () => new WeakMap());
+
+const SAMPLE_RATE = 0.01;
+
+// documented in src/docs/
+class Router {
+  NativeRouteIDs = NATIVE_ROUTE_IDS;
+  NativeListRouteIDs = NATIVE_LIST_ROUTE_IDS;
+  RouteTypes = ROUTE_TYPES;
+
+  constructor(appId: string, driver: Driver, membrane: Membrane) {
+    const members = {
+      appId,
+      driver,
+      currentRouteViewDriver: new DummyRouteViewDriver(),
+      allRoutesHandlerRegistry: new HandlerRegistry(),
+      customRoutes: [],
+      membrane,
+      listRouteHandlerRegistries: {},
+    };
+    Object.values(NATIVE_LIST_ROUTE_IDS).forEach((value: any) => {
+      members.listRouteHandlerRegistries[value] = new HandlerRegistry();
+    });
+    memberMap.set(this, members);
+
+    driver.getRouteViewDriverStream().onValue((routeViewDriver) => {
+      driver
+        .getLogger()
+        .trackFunctionPerformance(
+          () => _handleRouteViewChange(this, members, routeViewDriver),
+          SAMPLE_RATE,
+          {
+            type: 'handleRouteViewChange',
+            routeID: routeViewDriver.getRouteID(),
+          }
+        );
+    });
+
+    driver.getStopper().onValue(function () {
+      members.allRoutesHandlerRegistry.dumpHandlers();
+      Object.values(members.listRouteHandlerRegistries).forEach((reg: any) => {
+        reg.dumpHandlers();
+      });
+    });
+  }
+
+  createLink(routeID: string, params?: ?RouteParams | string): string {
+    return get(memberMap, this).driver.createLink(routeID, params);
+  }
+
+  goto(routeID: string, params?: ?RouteParams | string): Promise<void> {
+    if (typeof routeID !== 'string') {
+      throw new Error('routeID must be a string');
+    }
+    const { driver } = get(memberMap, this);
+    if (typeof params === 'string') {
+      driver
+        .getLogger()
+        .deprecationWarning(
+          'Router.goto param string',
+          'param object (e.g. {param: value})'
+        );
+    }
+    return driver.goto(routeID, params);
+  }
+
+  handleCustomRoute(
+    routeID: string,
+    handler: HandlerRegistry<CustomRouteView>
+  ): () => void {
+    const customRouteDescriptor = {
+      routeID: routeID,
+      onActivate: handler,
+    };
+
+    const removeCustomRouteFromDriver = get(
+      memberMap,
+      this
+    ).driver.addCustomRouteID(routeID);
+    const { customRoutes, driver } = get(memberMap, this);
+
+    customRoutes.push(customRouteDescriptor);
+
+    driver.getLogger().eventSdkPassive('Router.handleCustomRoute');
+
+    return function () {
+      removeCustomRouteFromDriver();
+      const index = customRoutes.indexOf(customRouteDescriptor);
+      if (index > -1) {
+        customRoutes.splice(index, 1);
+      }
+    };
+  }
+
+  handleAllRoutes(handler: Handler<any>): () => void {
+    return get(memberMap, this).allRoutesHandlerRegistry.registerHandler(
+      handler
+    );
+  }
+
+  handleListRoute(
+    routeID: string,
+    handler: Handler<ListRouteView>
+  ): () => void {
+    const { listRouteHandlerRegistries } = get(memberMap, this);
+    if (!listRouteHandlerRegistries[routeID]) {
+      throw new Error('Invalid routeID specified');
+    }
+
+    return listRouteHandlerRegistries[routeID].registerHandler(handler);
+  }
+
+  handleCustomListRoute(routeID: string, handler: Function): () => void {
+    return get(memberMap, this).driver.addCustomListRouteID(routeID, handler);
+  }
+
+  getCurrentRouteView(): RouteView {
+    const members = get(memberMap, this);
+    return members.membrane.get(members.currentRouteViewDriver);
+  }
+}
+
+function _handleRouteViewChange(router, members, routeViewDriver) {
+  if (members.currentRouteViewDriver instanceof DummyRouteViewDriver) {
+    members.currentRouteViewDriver.destroy();
+  }
+
+  members.currentRouteViewDriver = routeViewDriver;
+  const routeView = members.membrane.get(routeViewDriver);
+
+  _updateNavMenu(members, routeViewDriver);
+
+  if (routeView.getRouteType() === ROUTE_TYPES.CUSTOM) {
+    _informRelevantCustomRoutes(members, routeViewDriver, routeView);
+  }
+
+  members.allRoutesHandlerRegistry.addTarget(routeView);
+
+  if (routeView.getRouteType() === ROUTE_TYPES.LIST) {
+    const listRouteView = new ListRouteView(
+      routeViewDriver,
+      members.driver,
+      members.appId
+    );
+
+    const listRouteHandlerRegistry =
+      members.listRouteHandlerRegistries[routeView.getRouteID()];
+    if (listRouteHandlerRegistry) {
+      listRouteHandlerRegistry.addTarget(listRouteView);
+    }
+    members.listRouteHandlerRegistries[NATIVE_ROUTE_IDS.ANY_LIST].addTarget(
+      listRouteView
+    );
+  }
+}
+
+function _informRelevantCustomRoutes(members, routeViewDriver, routeView) {
+  const routeID = routeView.getRouteID();
+  const routeIDArray = Array.isArray(routeID) ? routeID : [routeID];
+  const relevantCustomRoute = find(
+    members.customRoutes,
+    (customRoute) =>
+      intersection(
+        Array.isArray(customRoute.routeID)
+          ? customRoute.routeID
+          : [customRoute.routeID],
+        routeIDArray
+      ).length
+  );
+
+  if (relevantCustomRoute) {
+    const customRouteView = new CustomRouteView(routeViewDriver);
+    const customViewElement = routeViewDriver.getCustomViewElement();
+    if (!customViewElement) throw new Error('should not happen');
+    members.driver.showCustomRouteView(customViewElement);
+    try {
+      relevantCustomRoute.onActivate(customRouteView);
+    } catch (err) {
+      members.driver.getLogger().error(err);
+    }
+  }
+}
+
+function _updateNavMenu(members, newRouteViewDriver) {
+  members.driver.setShowNativeNavMarker(
+    newRouteViewDriver.getType() !== ROUTE_TYPES.CUSTOM
+  );
+  members.driver.setShowNativeAddonSidebar(
+    newRouteViewDriver.getType() !== ROUTE_TYPES.CUSTOM
+  );
+}
+
+export default defn(module, Router);

package/src/platform-implementation-js/namespaces/search.js

@@ -0,0 +1,36 @@
+/* @flow */
+
+import get from '../../common/get-or-fail';
+import type { Driver } from '../driver-interfaces/driver';
+
+const memberMap = new WeakMap();
+
+// documented in src/docs/
+export default class Search {
+  constructor(appId: string, driver: Driver) {
+    const members = { appId, driver };
+    memberMap.set(this, members);
+  }
+
+  registerSearchSuggestionsProvider(handler: Function) {
+    if (typeof handler != 'function') {
+      throw new Error('Incorrect arguments');
+    }
+    const members = get(memberMap, this);
+    members.driver.registerSearchSuggestionsProvider(handler);
+  }
+
+  registerSearchQueryRewriter(rewriter: Object) {
+    if (
+      typeof rewriter.termReplacer != 'function' ||
+      typeof rewriter.term != 'string'
+    ) {
+      throw new Error('Incorrect arguments');
+    }
+    if (!rewriter.term.match(/^(app|has):/)) {
+      throw new Error("Custom search term must begin with 'app:'");
+    }
+    const members = get(memberMap, this);
+    members.driver.registerSearchQueryRewriter(rewriter);
+  }
+}