@inboxsdk/core 0.2.27 → 0.2.28-alpha.1

package/src/platform-implementation-js/dom-driver/gmail/gmail-driver/getSyncThreadForOldGmailThreadId.js

@@ -0,0 +1,38 @@
+/* @flow */
+
+import { defn } from 'ud';
+import BigNumber from 'bignumber.js';
+
+import getSyncThreadsForSearch from '../../../driver-common/getSyncThreadsForSearch';
+
+import gmailAjax from '../../../driver-common/gmailAjax';
+import isStreakAppId from '../../../lib/isStreakAppId';
+
+import { extractThreadsFromSearchResponse } from '../gmail-sync-response-processor';
+
+import type GmailDriver from '../gmail-driver';
+import type { SyncThread } from '../gmail-sync-response-processor';
+
+export default async function getSyncThreadForOldGmailThreadId(
+  driver: GmailDriver,
+  oldGmailThreadId: string
+): Promise<SyncThread> {
+  const { threads: threadDescriptors, _text } = await getSyncThreadsForSearch(
+    driver,
+    'threadid:' + new BigNumber(oldGmailThreadId, 16).toString(10)
+  );
+  const firstThread = threadDescriptors[0];
+  if (firstThread == null) {
+    console.error(`Thread with ID ${oldGmailThreadId} not found by Gmail`); //eslint-disable-line
+    const isStreak = isStreakAppId(driver.getAppId());
+    const err = new Error(
+      'Thread not found by getSyncThreadForOldGmailThreadId'
+    );
+    driver.getLogger().error(err, {
+      oldGmailThreadId: isStreak ? oldGmailThreadId : null,
+      responseText: isStreak ? _text : null,
+    });
+    throw err;
+  }
+  return firstThread;
+}

package/src/platform-implementation-js/dom-driver/gmail/gmail-driver/getSyncThreadFromSyncThreadId.js

@@ -0,0 +1,76 @@
+/* @flow */
+
+import { defn } from 'ud';
+import gmailAjax from '../../../driver-common/gmailAjax';
+import { extractThreadsFromThreadResponse } from '../gmail-sync-response-processor';
+import getAccountUrlPart from '../../../driver-common/getAccountUrlPart';
+import type GmailDriver from '../gmail-driver';
+import type { SyncThread } from '../gmail-sync-response-processor';
+
+export default async function getThreadFromSyncThreadId(
+  driver: GmailDriver,
+  syncThreadId: string
+): Promise<?SyncThread> {
+  const [btaiHeader, xsrfToken] = await Promise.all([
+    driver.getPageCommunicator().getBtaiHeader(),
+    driver.getPageCommunicator().getXsrfToken(),
+  ]);
+  return getThreadFromSyncThreadIdUsingHeaders(
+    syncThreadId,
+    btaiHeader,
+    xsrfToken
+  );
+}
+
+export async function getThreadFromSyncThreadIdUsingHeaders(
+  syncThreadId: string,
+  btaiHeader: string,
+  xsrfToken: string
+): Promise<?SyncThread> {
+  let responseText = null;
+  try {
+    let { text } = await gmailAjax({
+      method: 'POST',
+      url: `https://mail.google.com/sync${getAccountUrlPart()}/i/fd`,
+      headers: {
+        'Content-Type': 'application/json',
+        'X-Framework-Xsrf-Token': xsrfToken,
+        'X-Gmail-BTAI': btaiHeader,
+        'X-Google-BTD': '1',
+      },
+      data: JSON.stringify({
+        '1': [
+          {
+            '1': syncThreadId,
+            '2': 1,
+          },
+        ],
+      }),
+    });
+    responseText = text;
+  } catch (err) {
+    // try sending request with new format 2022_09_09
+    let { text } = await gmailAjax({
+      method: 'POST',
+      url: `https://mail.google.com/sync${getAccountUrlPart()}/i/fd?rt=r&pt=ji`,
+      headers: {
+        'Content-Type': 'application/json',
+        'X-Framework-Xsrf-Token': xsrfToken,
+        'X-Gmail-BTAI': btaiHeader,
+        'X-Google-BTD': '1',
+      },
+      data: JSON.stringify([[[syncThreadId, 1]], 2]),
+    });
+    responseText = text;
+  }
+
+  const threadDescriptors = extractThreadsFromThreadResponse(responseText);
+  if (threadDescriptors.length > 0) {
+    const thread = threadDescriptors[0];
+    if (thread.oldGmailThreadID) {
+      return thread;
+    }
+  }
+
+  return null;
+}

package/src/platform-implementation-js/dom-driver/gmail/gmail-driver/gmail-load-event.js

@@ -0,0 +1,61 @@
+/* @flow */
+
+import gmailElementGetter from '../gmail-element-getter';
+import type GmailDriver from '../gmail-driver';
+import isIntegratedViewGmail from './isIntegratedViewGmail';
+import { waitForMenuReady } from './add-nav-item';
+
+export default async function gmailLoadEvent(driver: GmailDriver) {
+  const pageCommunicator = driver.getPageCommunicator();
+
+  const isConversationViewDisabled =
+    await pageCommunicator.isConversationViewDisabled();
+  await waitForMenuReady();
+
+  driver.getLogger().eventSite('gmailSettings', {
+    isGmailIntegratedView: isIntegratedViewGmail(),
+    screenWidth: window.screen && window.screen.width,
+    screenHeight: window.screen && window.screen.height,
+    windowWidth: window.innerWidth,
+    windowHeight: window.innerHeight,
+    language: pageCommunicator.getUserLanguage(),
+    isUsingSyncAPI: pageCommunicator.isUsingSyncAPI(),
+    previewPane: pageCommunicator.getUserOriginalPreviewPaneMode(),
+    isConversationViewDisabled,
+    wasAccountSwitcherReadyAtStart:
+      driver.getEnvData().wasAccountSwitcherReadyAtStart,
+    timings: Object.assign(
+      ({
+        responseStart:
+          global.performance && global.performance.timing.responseStart,
+        responseEnd:
+          global.performance && global.performance.timing.responseEnd,
+        domLoading: global.performance && global.performance.timing.domLoading,
+        domInteractive:
+          global.performance && global.performance.timing.domInteractive,
+        domComplete:
+          global.performance && global.performance.timing.domComplete,
+        domContentLoadedEventStart:
+          global.performance &&
+          global.performance.timing.domContentLoadedEventStart,
+        domContentLoadedEventEnd:
+          global.performance &&
+          global.performance.timing.domContentLoadedEventEnd,
+        domainLookupEnd:
+          global.performance && global.performance.timing.domainLookupEnd,
+        domainLookupStart:
+          global.performance && global.performance.timing.domainLookupStart,
+        fetchStart: global.performance && global.performance.timing.fetchStart,
+        loadEventStart:
+          global.performance && global.performance.timing.loadEventStart,
+        loadEventEnd:
+          global.performance && global.performance.timing.loadEventEnd,
+        navigationStart:
+          global.performance && global.performance.timing.navigationStart,
+        requestStart:
+          global.performance && global.performance.timing.requestStart,
+      }: any),
+      driver.getTimings()
+    ),
+  });
+}

package/src/platform-implementation-js/dom-driver/gmail/gmail-driver/goto-view.js

@@ -0,0 +1,72 @@
+/* @flow */
+
+import includes from 'lodash/includes';
+import * as ud from 'ud';
+import { NATIVE_ROUTE_IDS } from '../../../constants/router';
+import { simulateClick } from '../../../lib/dom/simulate-mouse-event';
+import getURLObject from './get-url-object';
+
+import type GmailDriver from '../gmail-driver';
+import type { RouteParams } from '../../../namespaces/router';
+
+const gotoView = ud.defn(
+  module,
+  async function gotoView(
+    gmailDriver: GmailDriver,
+    viewName: string,
+    params: ?RouteParams | string
+  ): Promise<void> {
+    if (viewName[0] === '#') {
+      if (params) {
+        throw new Error("params parameter can't be passed with resolved URL");
+      }
+      viewName = viewName.slice(1);
+    }
+
+    if (includes(NATIVE_ROUTE_IDS, viewName)) {
+      if (gmailDriver.isUsingSyncAPI()) {
+        // need to go to the new url
+        if (params && typeof params !== 'string') {
+          const threadID = params.threadID;
+          if (threadID && typeof threadID === 'string') {
+            const int = parseInt(threadID, 16);
+            if (!isNaN(int)) {
+              //we got an old id
+              const syncThreadId =
+                await gmailDriver.getSyncThreadIdForOldGmailThreadId(threadID);
+              params = {
+                ...params,
+                threadID: '#' + syncThreadId,
+              };
+            }
+          }
+        }
+      }
+
+      const newHash = gmailDriver.createLink(viewName, params);
+      // Create a fake link and simulate a click event on it to let Gmail handle
+      // the view change. If we just set window.location.hash ourselves to the
+      // newHash, it's a Gmail hash, and any composes are open, then Gmail will
+      // redirect the user to the hash with ?compose=... appended to the end and
+      // break the back button. If we try to pre-empt Gmail and add the
+      // ?compose=... part ourselves, then sometimes Gmail thinks it's new and
+      // actually triggers now composes to open. This fake link method avoids the
+      // issue.
+      const link = document.createElement('a');
+      link.style.display = 'none';
+      link.href = newHash;
+      ((document.body: any): HTMLElement).appendChild(link);
+      simulateClick(link);
+      link.remove();
+    } else {
+      const newHash = gmailDriver.createLink(viewName, params);
+      // If it's not a gmail view name, then it's probably a hash for a custom
+      // view. We need to set the hash ourselves. Gmail won't react at all to a
+      // hashchange event for a hash it doesn't recognize, so we don't have to
+      // worry about the above issue.
+      window.location.hash = newHash;
+    }
+  }
+);
+
+export default gotoView;

package/src/platform-implementation-js/dom-driver/gmail/gmail-driver/isIntegratedViewGmail.d.ts

@@ -0,0 +1,2 @@
+export default function isIntegratedViewGmail(): boolean;
+//# sourceMappingURL=isIntegratedViewGmail.d.ts.map

package/src/platform-implementation-js/dom-driver/gmail/gmail-driver/isIntegratedViewGmail.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isIntegratedViewGmail.d.ts","sourceRoot":"","sources":["../../../../../../../src/platform-implementation-js/dom-driver/gmail/gmail-driver/isIntegratedViewGmail.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,OAAO,UAAU,qBAAqB,IAAI,OAAO,CAGvD"}

package/src/platform-implementation-js/dom-driver/gmail/gmail-driver/keyboard-shortcut-help-modifier.js

@@ -0,0 +1,226 @@
+/* @flow */
+
+import escape from 'lodash/escape';
+import * as Kefir from 'kefir';
+import kefirStopper from 'kefir-stopper';
+import type { Stopper } from 'kefir-stopper';
+import makeElementChildStream from '../../../lib/dom/make-element-child-stream';
+import querySelector from '../../../lib/dom/querySelectorOrFail';
+import makeMutationObserverChunkedStream from '../../../lib/dom/make-mutation-observer-chunked-stream';
+import type KeyboardShortcutHandle from '../../../views/keyboard-shortcut-handle';
+
+export default class KeyboardShortcutHelpModifier {
+  _appId: ?string;
+  _appName: ?string;
+  _appIconUrl: ?string;
+  _stopper: Stopper;
+  _shortcuts: Set<KeyboardShortcutHandle>;
+
+  constructor() {
+    this._appId = null; // TODO have these passed to the constructor
+    this._appName = null;
+    this._appIconUrl = null;
+
+    this._stopper = kefirStopper();
+    this._shortcuts = new Set();
+    this._monitorKeyboardHelp();
+  }
+
+  destroy() {
+    this._stopper.destroy();
+    this._shortcuts.clear();
+  }
+
+  set(
+    keyboardShortcutHandle: KeyboardShortcutHandle,
+    appId: string,
+    appName: ?string,
+    appIconUrl: ?string
+  ) {
+    this._initializeAppValues(appId, appName, appIconUrl);
+
+    this._shortcuts.add(keyboardShortcutHandle);
+  }
+
+  delete(keyboardShortcutHandle: KeyboardShortcutHandle) {
+    this._shortcuts.delete(keyboardShortcutHandle);
+  }
+
+  _initializeAppValues(appId: string, appName: ?string, appIconUrl: ?string) {
+    if (!this._appId) {
+      this._appId = appId;
+    }
+
+    if (!this._appName) {
+      this._appName = appName;
+    }
+
+    if (!this._appIconUrl) {
+      this._appIconUrl = appIconUrl;
+    }
+  }
+
+  _monitorKeyboardHelp() {
+    makeElementChildStream(((document.body: any): HTMLElement))
+      .map((event) => event.el)
+      .filter((node) => node && node.classList && node.classList.contains('wa'))
+      .flatMap((node) =>
+        makeMutationObserverChunkedStream(node, {
+          attributes: true,
+          attributeFilter: ['class'],
+        })
+          .filter(() => !node.classList.contains('aou'))
+          .toProperty(() => null)
+          .map(() => node)
+      )
+      .takeUntilBy(this._stopper)
+      .onValue((node) => this._renderHelp(node));
+  }
+
+  _renderHelp(node: HTMLElement) {
+    if (this._shortcuts.size === 0) {
+      return;
+    }
+
+    var keys = this._shortcuts.keys();
+
+    var header = this._renderHeader();
+    var table = this._renderTable();
+
+    var bodies = table.querySelectorAll('tbody tbody');
+
+    var index = 0;
+    this._shortcuts.forEach((keyboardShortcutHandle) => {
+      this._renderShortcut(bodies[index % 2], keyboardShortcutHandle);
+      index++;
+    });
+
+    const firstHeader = querySelector(node, '.aov');
+    const parent = firstHeader.parentElement;
+    if (!parent) throw new Error('Could not find parent');
+    parent.insertBefore(header, firstHeader);
+    parent.insertBefore(table, firstHeader);
+  }
+
+  _renderHeader(): HTMLElement {
+    const header = document.createElement('div');
+    header.setAttribute('class', 'aov  aox');
+    header.innerHTML = [
+      '<div class="aow">',
+      '<span class="inboxsdk__shortcutHelp_title">',
+      escape(this._appName || this._appId) + ' keyboard shortcuts',
+      '</span>',
+      '</div>',
+    ].join('');
+
+    if (this._appIconUrl) {
+      const img = document.createElement('img');
+      if (this._appIconUrl) {
+        img.src = this._appIconUrl;
+      }
+      img.setAttribute('class', 'inboxsdk__icon');
+
+      const title = querySelector(header, '.inboxsdk__shortcutHelp_title');
+      title.insertBefore(img, title.firstChild);
+    }
+
+    return header;
+  }
+
+  _renderTable(): HTMLElement {
+    var table = document.createElement('table');
+    table.setAttribute('cellpadding', '0');
+    table.setAttribute('class', 'cf wd inboxsdk__shortcutHelp_table');
+
+    table.innerHTML = [
+      '<tbody>',
+      '<tr>',
+      '<td class="Dn">',
+      '<table cellpadding="0" class="cf">',
+      '<tbody>',
+      '<tr><th>&nbsp;</th><th>&nbsp;</th></tr>',
+      '</tbody>',
+      '</table>',
+      '</td>',
+      '<td class="Dn">',
+      '<table cellpadding="0" class="cf">',
+      '<tbody>',
+      '<tr><th>&nbsp;</th><th>&nbsp;</th></tr>',
+      '</tbody>',
+      '</table>',
+      '</td>',
+      '</tr',
+      '</tbody>',
+    ].join('');
+
+    return table;
+  }
+
+  _renderShortcut(
+    tableBody: HTMLElement,
+    keyboardShortcutHandle: KeyboardShortcutHandle
+  ) {
+    var shortcutRow = document.createElement('tr');
+    shortcutRow.innerHTML = [
+      '<td class="wg Dn"> ',
+      _getShortcutHTML(keyboardShortcutHandle.chord),
+      '</td>',
+      '<td class="we Dn"> ',
+      escape(keyboardShortcutHandle.description || ''),
+      '</td>',
+    ].join('');
+
+    tableBody.appendChild(shortcutRow);
+  }
+}
+
+function _getShortcutHTML(chord: string): string {
+  const retArray = [];
+
+  const parts = chord.split(/[\s+]/g);
+  const separators = chord.match(/[\s+]/g);
+
+  for (var ii = 0; ii < parts.length; ii++) {
+    retArray.push(
+      '<span class="wh">' + escape(_getAngledBracket(parts[ii])) + '</span>'
+    );
+    if (separators && separators[ii]) {
+      retArray.push(_getSeparatorHTML(separators[ii]));
+    }
+  }
+
+  retArray.push(' :');
+
+  return retArray.join('');
+}
+
+function _getAngledBracket(chordChar: string): string {
+  switch (chordChar.toLowerCase()) {
+    case 'shift':
+      return '<Shift>';
+    case 'ctrl':
+      return '<Ctrl>';
+    case 'alt':
+      return '<Alt>';
+    case 'meta':
+    case 'command':
+      return '<⌘>';
+    case 'mod':
+      // Operating system check copied from Combokeys.
+      // https://github.com/avocode/combokeys/blob/0b80e13cf7e5217c5b4fbd393289a87b1f48f7cc/helpers/special-aliases.js#L14
+      return /Mac|iPod|iPhone|iPad/.test(navigator.platform) ? '<⌘>' : '<Ctrl>';
+    default:
+      return chordChar;
+  }
+}
+
+function _getSeparatorHTML(separator: string): string {
+  switch (separator) {
+    case ' ':
+      return '<span class="wb">then</span> ';
+    case '+':
+      return ' <span class="wb">+</span> ';
+    default:
+      return '';
+  }
+}

package/src/platform-implementation-js/dom-driver/gmail/gmail-driver/open-compose-window.js

@@ -0,0 +1,27 @@
+/* @flow */
+
+import { simulateClick } from '../../../lib/dom/simulate-mouse-event';
+import GmailElementGetter from '../gmail-element-getter';
+
+import waitFor from '../../../lib/wait-for';
+
+import type GmailDriver from '../gmail-driver';
+
+export default async function openComposeWindow(gmailDriver: GmailDriver) {
+  await GmailElementGetter.waitForGmailModeToSettle();
+
+  if (
+    GmailElementGetter.isStandaloneComposeWindow() ||
+    GmailElementGetter.isStandaloneThreadWindow()
+  ) {
+    throw new Error('Can not open new compose while in standalone window');
+  }
+
+  if (!GmailElementGetter.getComposeButton()) {
+    await waitFor(() => !!GmailElementGetter.getComposeButton());
+  }
+
+  const composeButton = GmailElementGetter.getComposeButton();
+  if (!composeButton) throw new Error('Could not find compose button');
+  simulateClick(composeButton);
+}

package/src/platform-implementation-js/dom-driver/gmail/gmail-driver/open-draft-by-message-id.d.ts

@@ -0,0 +1,5 @@
+import GmailDriver from '../gmail-driver';
+export default function openDraftByMessageID(driver: GmailDriver, messageID: string): Promise<void>;
+export declare function makeNewHash(oldHash: string, messageID: string): string;
+export declare function makeNewSyncHash(oldHash: string, syncThreadID: string, syncMessageID: string): string;
+//# sourceMappingURL=open-draft-by-message-id.d.ts.map

package/src/platform-implementation-js/dom-driver/gmail/gmail-driver/open-draft-by-message-id.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"open-draft-by-message-id.d.ts","sourceRoot":"","sources":["../../../../../../../src/platform-implementation-js/dom-driver/gmail/gmail-driver/open-draft-by-message-id.ts"],"names":[],"mappings":"AAIA,OAAO,WAAW,MAAM,iBAAiB,CAAC;AAI1C,wBAA8B,oBAAoB,CAChD,MAAM,EAAE,WAAW,EACnB,SAAS,EAAE,MAAM,iBAoClB;AAED,wBAAgB,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAUtE;AAED,wBAAgB,eAAe,CAC7B,OAAO,EAAE,MAAM,EACf,YAAY,EAAE,MAAM,EACpB,aAAa,EAAE,MAAM,GACpB,MAAM,CAOR"}

package/src/platform-implementation-js/dom-driver/gmail/gmail-driver/open-draft-by-message-id.test.js

@@ -0,0 +1,23 @@
+/* @flow */
+
+import openDraftByMessageID, { makeNewHash } from './open-draft-by-message-id';
+
+describe('makeNewHash', () => {
+  it('1', () => {
+    expect(makeNewHash('', '123')).toBe('#?compose=123');
+  });
+  it('2', () => {
+    expect(makeNewHash('#', '123')).toBe('#?compose=123');
+  });
+  it('3', () => {
+    expect(makeNewHash('#inbox', '123')).toBe('#inbox?compose=123');
+  });
+  it('4', () => {
+    expect(makeNewHash('#inbox?compose=123', '456')).toBe(
+      '#inbox?compose=123%2C456'
+    );
+  });
+  it('5', () => {
+    expect(makeNewHash('#inbox?foo=5', '123')).toBe('#inbox?foo=5&compose=123');
+  });
+});

package/src/platform-implementation-js/dom-driver/gmail/gmail-driver/override-gmail-back-button.js

@@ -0,0 +1,92 @@
+/* @flow */
+
+import Kefir from 'kefir';
+import { defn } from 'ud';
+import GmailElementGetter from '../gmail-element-getter';
+import onMouseDownAndUp from '../../../lib/dom/on-mouse-down-and-up';
+import type GmailDriver from '../gmail-driver';
+import type GmailRouteView from '../views/gmail-route-view/gmail-route-view';
+import type GmailRouteProcessor from '../views/gmail-route-view/gmail-route-processor';
+
+export default function overrideGmailBackButton(
+  gmailDriver: GmailDriver,
+  gmailRouteProcessor: GmailRouteProcessor
+) {
+  GmailElementGetter.waitForGmailModeToSettle().then(function () {
+    if (GmailElementGetter.isStandalone()) {
+      return;
+    }
+    _setupManagement(gmailDriver, gmailRouteProcessor);
+  });
+}
+
+function _setupManagement(gmailDriver, gmailRouteProcessor) {
+  gmailDriver
+    .getRouteViewDriverStream()
+    .scan(
+      (
+        prev: ?{ gmailRouteView: GmailRouteView },
+        gmailRouteView: GmailRouteView
+      ) => {
+        let lastCustomRouteID, lastCustomRouteParams;
+        if (
+          prev &&
+          prev.gmailRouteView &&
+          prev.gmailRouteView.isCustomRouteBelongingToApp()
+        ) {
+          lastCustomRouteID = prev.gmailRouteView.getRouteID();
+          lastCustomRouteParams = prev.gmailRouteView.getParams();
+        }
+        return { gmailRouteView, lastCustomRouteID, lastCustomRouteParams };
+      },
+      undefined
+    )
+    .changes()
+    .onValue(({ gmailRouteView, lastCustomRouteID, lastCustomRouteParams }) => {
+      handleGmailRouteView(
+        gmailRouteView,
+        lastCustomRouteID,
+        lastCustomRouteParams,
+        gmailDriver,
+        gmailRouteProcessor
+      );
+    });
+}
+
+const handleGmailRouteView = defn(
+  module,
+  function handleGmailRouteView(
+    gmailRouteView: GmailRouteView,
+    lastCustomRouteID: ?string,
+    lastCustomRouteParams: ?Object,
+    gmailDriver: GmailDriver,
+    gmailRouteProcessor: GmailRouteProcessor
+  ) {
+    if (
+      lastCustomRouteID &&
+      gmailRouteView.getRouteType() === gmailRouteProcessor.RouteTypes.THREAD
+    ) {
+      _bindToBackButton(gmailDriver, gmailRouteView);
+    }
+  }
+);
+
+function _bindToBackButton(
+  gmailDriver: GmailDriver,
+  gmailRouteView: GmailRouteView
+) {
+  const backButton = GmailElementGetter.getThreadBackButton();
+
+  if (!backButton) {
+    return;
+  }
+
+  onMouseDownAndUp(backButton)
+    .takeUntilBy(gmailRouteView.getStopper())
+    .filter((e) => !e.defaultPrevented)
+    .onValue((e) => {
+      window.history.back();
+      e.preventDefault();
+      e.stopImmediatePropagation();
+    });
+}

package/src/platform-implementation-js/dom-driver/gmail/gmail-driver/register-search-query-rewriter.js

@@ -0,0 +1,30 @@
+/* @flow */
+
+import type PageCommunicator from '../gmail-page-communicator';
+
+export default function registerSearchQueryRewriter(
+  pageCommunicator: PageCommunicator,
+  obj: Object
+) {
+  pageCommunicator.createCustomSearchTerm(obj.term);
+
+  pageCommunicator.ajaxInterceptStream
+    .filter((event) => {
+      return (
+        event.type === 'searchQueryForReplacement' && event.term === obj.term
+      );
+    })
+    .onValue((event) => {
+      Promise.resolve(obj.termReplacer({})).then((result) => {
+        if (typeof result != 'string') {
+          throw new Error('termReplacer response must be a string');
+        }
+        const newTerm = '(' + result + ')';
+        const newQuery = event.query.replace(
+          obj.term,
+          () => newTerm // Callback used so $ escapes aren't interpreted
+        );
+        pageCommunicator.setSearchQueryReplacement(event.query, newQuery);
+      });
+    });
+}