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

package/src/platform-implementation-js/dom-driver/gmail/gmail-element-getter/get-main-content-element-changed-stream.js

@@ -0,0 +1,38 @@
+import last from 'lodash/last';
+import * as Kefir from 'kefir';
+import streamWaitFor from '../../../lib/stream-wait-for';
+import makeMutationObserverChunkedStream from '../../../lib/dom/make-mutation-observer-chunked-stream';
+import makeElementChildStream from '../../../lib/dom/make-element-child-stream';
+export default function getMainContentElementChangedStream(GmailElementGetter) {
+    const s = waitForMainContentContainer(GmailElementGetter)
+        .flatMap((mainContentContainer) => makeElementChildStream(mainContentContainer)
+        .filter(({ el }) => el.classList.contains('nH'))
+        .flatMap(({ el, removalStream }) => makeMutationObserverChunkedStream(el, {
+        attributes: true,
+        attributeFilter: ['style'],
+    })
+        .map((x) => last(x))
+        .toProperty(() => {
+        return { target: el };
+    })
+        .filter(_isNowVisible)
+        .map((e) => e.target)
+        .takeUntilBy(removalStream)))
+        .toProperty();
+    // Make sure we always have a subscriber. The function breaks if it loses all
+    // subscribers and then re-gains some.
+    s.onValue(() => {
+        // ignore, just activate
+    });
+    return s;
+}
+function waitForMainContentContainer(GmailElementGetter) {
+    if (GmailElementGetter.isStandaloneComposeWindow()) {
+        return Kefir.never();
+    }
+    return streamWaitFor(() => GmailElementGetter.getMainContentContainer());
+}
+function _isNowVisible(mutation) {
+    const el = mutation.target;
+    return el.style.display !== 'none';
+}

package/src/platform-implementation-js/dom-driver/gmail/gmail-element-getter/wait-for-gmail-mode-to-settle.js

@@ -0,0 +1,12 @@
+import once from 'lodash/once';
+import makeMutationObserverChunkedStream from '../../../lib/dom/make-mutation-observer-chunked-stream';
+const waitForGmailModeToSettle = once(() => makeMutationObserverChunkedStream(document.body, {
+    attributes: true,
+    attributeFilter: ['class'],
+})
+    .toProperty(() => undefined)
+    .filter(() => document.body.classList.length > 0)
+    .map(() => undefined)
+    .take(1)
+    .toProperty());
+export default waitForGmailModeToSettle;

package/src/platform-implementation-js/dom-driver/gmail/gmail-element-getter.js

@@ -0,0 +1,253 @@
+import once from 'lodash/once';
+import * as Kefir from 'kefir';
+import makeElementChildStream from '../../lib/dom/make-element-child-stream';
+import querySelector from '../../lib/dom/querySelectorOrFail';
+import waitForGmailModeToSettle from './gmail-element-getter/wait-for-gmail-mode-to-settle';
+import getMainContentElementChangedStream from './gmail-element-getter/get-main-content-element-changed-stream';
+import isIntegratedViewGmail from './gmail-driver/isIntegratedViewGmail';
+import Logger from '../../lib/logger';
+import waitFor from '../../lib/wait-for';
+// TODO Figure out if these functions can and should be able to return null
+const GmailElementGetter = {
+    getActiveMoreMenu() {
+        const elements = document.querySelectorAll('.J-M.aX0.aYO.jQjAxd');
+        for (let ii = 0; ii < elements.length; ii++) {
+            if (elements[ii].style.display !== 'none') {
+                return elements[ii];
+            }
+        }
+        return null;
+    },
+    getAddonSidebarContainerElement() {
+        // only for Gmailv1 + Gmailv2-before-2018-07-30?
+        return document.querySelector('.no > .nn.bnl');
+    },
+    getCompanionSidebarContentContainerElement() {
+        return document.querySelector('.brC-brG');
+    },
+    // <div class="brC-aT5-aOt-Jw" role="navigation" aria-label="Side panel">
+    getCompanionSidebarIconContainerElement() {
+        return document.querySelector('.brC-aT5-aOt-Jw');
+    },
+    getComposeButton() {
+        if (isIntegratedViewGmail()) {
+            return document.querySelector('.aIH .aic div[role=button].L3');
+        }
+        return document.querySelector('[gh=cm]');
+    },
+    getComposeWindowContainer() {
+        return document.querySelector('.dw .nH > .nH > .no');
+    },
+    getContentSectionElement() {
+        // New method for finding the content section element that also supports
+        // Gmail integrated view. Use it if we're in Gmail integrated view.
+        // Otherwise, use the old method, but log a warning if the old method
+        // finds something different than the old method, so that way we can
+        // figure out if it's okay to swap over.
+        const el = document.querySelector('div.nH.bkK > .nH');
+        if (isIntegratedViewGmail()) {
+            return el;
+        }
+        else {
+            const leftNavContainer = GmailElementGetter.getLeftNavContainerElement();
+            const oldMethodEl = leftNavContainer
+                ? leftNavContainer.nextElementSibling.children[0]
+                : null;
+            if (el !== oldMethodEl) {
+                Logger.error(new Error('getContentSectionElement old and new method inconsistency'), {
+                    elClassName: el?.className,
+                    oldMethodClassName: oldMethodEl?.className,
+                });
+            }
+            return oldMethodEl;
+        }
+    },
+    getFullscreenComposeWindowContainer() {
+        return document.querySelector('.aSs .aSt');
+    },
+    getFullscreenComposeWindowContainerStream() {
+        if (!document.body)
+            throw new Error();
+        return (makeElementChildStream(document.body)
+            .filter(({ el }) => el.classList.contains('aSs'))
+            .flatMap(({ el, removalStream }) => makeElementChildStream(el).takeUntilBy(removalStream))
+            .filter(({ el }) => el.classList.contains('aSt'))
+            // Assume that only one element will come through and will never be removed from the page.
+            .take(1)
+            .map(({ el }) => ({ el, removalStream: Kefir.never() }))
+            .toProperty());
+    },
+    getGtalkButtons() {
+        return document.querySelector('.aeN .aj5.J-KU-Jg');
+    },
+    getLeftNavContainerElement() {
+        if (isIntegratedViewGmail()) {
+            return document.querySelector('div[role=navigation] + div.aqn');
+        }
+        return document.querySelector('.aeN');
+    },
+    getLeftNavHeightElement() {
+        return document.querySelector('.aeN');
+    },
+    getMainContentBodyContainerElement() {
+        return document.querySelector('.no > .nn.bkK');
+    },
+    getMainContentContainer() {
+        // This method used to just look for the div[role=main] element and then
+        // return its parent, but it turns out the Contacts page does not set
+        // role=main.
+        return document.querySelector('div.aeF > div.nH');
+    },
+    getMainContentElementChangedStream: once(function () {
+        return getMainContentElementChangedStream(this);
+    }),
+    getMoleParent() {
+        return document.body.querySelector('.dw .nH > .nH > .no');
+    },
+    // This function checks whether we should use the old InboxSDK style of adding nav items
+    // inline among Gmail's nav items (as opposed to the newer style where we put our nav items
+    // in their own sections at the bottom of the leftnav).
+    shouldAddNavItemsInline() {
+        // There's three cases this function should return true:
+        // - The user is in a pre-Google-Chat Hangouts-only version of Gmail (the Gmail Settings ->
+        //   Chat and Meet -> Chat menu only has the options "Hangouts On" and "Hangouts Off").
+        // - The user has "Classic Hangouts" picked in Gmail Settings -> Chat and Meet -> Chat.
+        // - Integrated view gmail.
+        if (isIntegratedViewGmail()) {
+            return true;
+        }
+        const leftNavElement = document.querySelector('.aeN[role=navigation], .aeN [role=navigation]');
+        if (!leftNavElement) {
+            throw new Error('shouldAddNavItemsInline failed to find leftNavElement');
+        }
+        // leftNavElement classnames depending on gmail chat & meet settings:
+        // Old Hangouts-only Gmail
+        //  div.aeN.WR.nH.oy8Mbf.nn
+        //  (looks identical to current Gmail's chat-off-meet-off setup, but there are important
+        //  CSS differences inside the element!)
+        // ===================
+        // No classname difference between open/collapsed
+        //  div.ajl.aib.aZ6 (classic hangouts on left or right, google meet on/off)
+        // ===================
+        // Collapsed gets .bhZ class added
+        //  div.aeN.WR.nH.oy8Mbf.nn (chat off, google meet off)
+        //  div.aeN.WR.BaIAZe.anZ.nH.oy8Mbf.nn (chat off, google meet on)
+        //  div.aeN.WR.anZ.nH.oy8Mbf.nn (google chat on left, google meet on/off)
+        //  div.aeN.WR.ahu.nH.oy8Mbf.nn (google chat on right, google meet on/off)
+        if (leftNavElement.classList.contains('aZ6')) {
+            return true;
+        }
+        else {
+            return false;
+        }
+    },
+    getAppMenuAsync: once(async () => {
+        if (!GmailElementGetter.isStandalone()) {
+            await GmailElementGetter.waitForGmailModeToSettle();
+            /**
+             * The selector for the new app menu https://support.google.com/mail/answer/11555490 -- FEB 2023
+             */
+            const APP_MENU = '.aeN.WR.a6o.anZ.nH.oy8Mbf[role=navigation]';
+            /**
+             * If the APP_MENU selector is not found, NAV_MENU _might_ be present.
+             */
+            const NAV_MENU = '.aeN.WR.nH.oy8Mbf[role=navigation]';
+            try {
+                const element = await waitFor(() => document.querySelector(`${APP_MENU}, ${NAV_MENU}`));
+                if (!document.querySelector(APP_MENU)) {
+                    return;
+                }
+                return element;
+            }
+            catch (e) {
+                Logger.error(e);
+            }
+        }
+    }),
+    getAppMenuContainer() {
+        return document.querySelector('.aqk.aql.bkL');
+    },
+    // TODO figure out if we use it
+    // getNavMenu() {
+    //   return document.querySelector('.aeN.WR.nH.oy8Mbf[role=navigation]');
+    // },
+    getSeparateSectionNavItemMenuInjectionContainer() {
+        return document.querySelector('.aeN');
+    },
+    getSameSectionNavItemMenuInjectionContainer() {
+        if (isIntegratedViewGmail()) {
+            return document.querySelector('.yJ .wT > .n3');
+        }
+        else {
+            return document.querySelector('.aeN .n3');
+        }
+    },
+    getRowListElements() {
+        return Array.from(document.querySelectorAll('[gh=tl]'));
+    },
+    getScrollContainer() {
+        return document.querySelector('div.Tm.aeJ');
+    },
+    getSearchInput() {
+        return document.querySelector('form[role=search] input');
+    },
+    getSearchSuggestionsBoxParent() {
+        return document.querySelector('table.gstl_50 > tbody > tr > td.gssb_e');
+    },
+    getSidebarContainerElement() {
+        return document.querySelector('[role=main] table.Bs > tr .y3');
+    },
+    getThreadBackButton() {
+        let toolbarElement;
+        try {
+            toolbarElement = GmailElementGetter.getToolbarElement();
+        }
+        catch (err) {
+            return null;
+        }
+        return toolbarElement.querySelector('.lS');
+    },
+    getThreadContainerElement() {
+        return document.querySelector('[role=main] .g.id table.Bs > tr');
+    },
+    getToolbarElement() {
+        return querySelector(document, '[gh=tm]');
+    },
+    getTopAccountContainer() {
+        return document.querySelector('header[role="banner"] > div:nth-child(2) > div:nth-child(2)');
+    },
+    isGplusEnabled() {
+        const topAccountContainer = GmailElementGetter.getTopAccountContainer();
+        if (!topAccountContainer) {
+            return false;
+        }
+        return (topAccountContainer.querySelectorAll('a[href*="https://plus"][href*="upgrade"]').length === 0);
+    },
+    isDarkTheme() {
+        return document.body.classList.contains('inboxsdk__gmail_dark_theme');
+    },
+    isPreviewPane() {
+        return !!document.querySelector('.aia');
+    },
+    isStandalone() {
+        return this.isStandaloneComposeWindow() || this.isStandaloneThreadWindow();
+    },
+    isStandaloneComposeWindow() {
+        return (document.body.classList.contains('xE') &&
+            document.body.classList.contains('xp'));
+    },
+    isStandaloneThreadWindow() {
+        return (document.body.classList.contains('aAU') &&
+            document.body.classList.contains('xE') &&
+            document.body.classList.contains('Su'));
+    },
+    StandaloneCompose: {
+        getComposeWindowContainer() {
+            return document.querySelector('[role=main]');
+        },
+    },
+    waitForGmailModeToSettle() {
+        return waitForGmailModeToSettle().toPromise();
+    },
+};
+export default GmailElementGetter;

package/src/platform-implementation-js/dom-driver/gmail/gmail-page-communicator.js

@@ -0,0 +1,200 @@
+import CommonPageCommunicator from '../../lib/common-page-communicator';
+import makeMutationObserverChunkedStream from '../../lib/dom/make-mutation-observer-chunked-stream';
+import Kefir from 'kefir';
+// This is intended to be instantiated from makeXhrInterceptor, since it depends
+// on the injected script, and if it's not instantiated elsewhere, you know that
+// if you have an instance of this, then the injected script is present and this
+// will work.
+export default class GmailPageCommunicator extends CommonPageCommunicator {
+    async getMessageDate(threadId, message) {
+        return this._getMessageData(threadId, message, 'data-inboxsdk-sortdate', 'inboxSDKtellMeThisMessageDate');
+    }
+    async getMessageRecipients(threadId, message) {
+        return this._getMessageData(threadId, message, 'data-inboxsdk-recipients', 'inboxSDKtellMeThisMessageRecipients');
+    }
+    async _getMessageData(threadId, message, attribute, eventName) {
+        let data = message.getAttribute(attribute);
+        if (!data) {
+            const [btaiHeader, xsrfToken] = this.isUsingSyncAPI()
+                ? await Promise.all([this.getBtaiHeader(), this.getXsrfToken()])
+                : [null, null];
+            message.dispatchEvent(new CustomEvent(eventName, {
+                bubbles: true,
+                cancelable: false,
+                detail: {
+                    threadId,
+                    ikValue: this.getIkValue(),
+                    btaiHeader,
+                    xsrfToken,
+                },
+            }));
+            data = message.getAttribute(attribute);
+            if (!data) {
+                await makeMutationObserverChunkedStream(message, {
+                    attributes: true,
+                    attributeFilter: [attribute],
+                })
+                    .take(1)
+                    .toPromise();
+                data = message.getAttribute(attribute);
+            }
+        }
+        if (data && data !== 'error')
+            return JSON.parse(data);
+        else
+            return null;
+    }
+    getThreadIdForThreadRowByDatabase(threadRow) {
+        let threadid = threadRow.getAttribute('data-inboxsdk-threadid');
+        if (!threadid) {
+            threadRow.dispatchEvent(new CustomEvent('inboxSDKtellMeThisThreadIdByDatabase', {
+                bubbles: true,
+                cancelable: false,
+                detail: null,
+            }));
+            threadid = threadRow.getAttribute('data-inboxsdk-threadid');
+        }
+        return threadid;
+    }
+    getThreadIdForThreadRowByClick(threadRow) {
+        let threadid = threadRow.getAttribute('data-inboxsdk-threadid');
+        if (!threadid) {
+            threadRow.dispatchEvent(new CustomEvent('inboxSDKtellMeThisThreadIdByClick', {
+                bubbles: true,
+                cancelable: false,
+                detail: null,
+            }));
+            threadid = threadRow.getAttribute('data-inboxsdk-threadid');
+        }
+        return threadid;
+    }
+    getCurrentThreadID(threadContainerElement, isPreviewedThread = false) {
+        threadContainerElement.dispatchEvent(new CustomEvent('inboxSDKtellMeCurrentThreadId', {
+            bubbles: true,
+            cancelable: false,
+            detail: { isPreviewedThread },
+        }));
+        const s = threadContainerElement.getAttribute('data-inboxsdk-currentthreadid');
+        if (s == null)
+            throw new Error('Failed to read value');
+        return s;
+    }
+    getUserOriginalPreviewPaneMode() {
+        return document.head.getAttribute('data-inboxsdk-user-preview-pane-mode');
+    }
+    getActionTokenValue() {
+        const s = document.head.getAttribute('data-inboxsdk-action-token-value');
+        if (s == null)
+            throw new Error('Failed to read value');
+        return s;
+    }
+    isUsingSyncAPI() {
+        const s = document.head.getAttribute('data-inboxsdk-using-sync-api');
+        if (s == null)
+            throw new Error('Failed to read value');
+        return s === 'true';
+    }
+    isConversationViewDisabled() {
+        return new Promise((resolve) => {
+            Kefir.fromEvents(document, 'inboxSDKgmonkeyResponse')
+                .take(1)
+                .onValue((event) => {
+                resolve(event.detail);
+            });
+            document.dispatchEvent(new CustomEvent('inboxSDKtellMeIsConversationViewDisabled', {
+                bubbles: false,
+                cancelable: false,
+                detail: null,
+            }));
+        });
+    }
+    registerSuggestionsModifier(providerID) {
+        document.dispatchEvent(new CustomEvent('inboxSDKregisterSuggestionsModifier', {
+            bubbles: false,
+            cancelable: false,
+            detail: { providerID },
+        }));
+    }
+    provideAutocompleteSuggestions(providerID, query, suggestions) {
+        document.dispatchEvent(new CustomEvent('inboxSDKprovideSuggestions', {
+            bubbles: false,
+            cancelable: false,
+            detail: {
+                providerID,
+                query,
+                // Filter out non-JSONifiable things
+                suggestions: JSON.parse(JSON.stringify(suggestions)),
+            },
+        }));
+    }
+    setupCustomListResultsQuery(query) {
+        document.dispatchEvent(new CustomEvent('inboxSDKcustomListRegisterQuery', {
+            bubbles: false,
+            cancelable: false,
+            detail: { query },
+        }));
+    }
+    setCustomListNewQuery(detail) {
+        document.dispatchEvent(new CustomEvent('inboxSDKcustomListNewQuery', {
+            bubbles: false,
+            cancelable: false,
+            detail,
+        }));
+    }
+    setCustomListResults(query, newResults) {
+        document.dispatchEvent(new CustomEvent('inboxSDKcustomListResults', {
+            bubbles: false,
+            cancelable: false,
+            detail: { query, newResults },
+        }));
+    }
+    createCustomSearchTerm(term) {
+        document.dispatchEvent(new CustomEvent('inboxSDKcreateCustomSearchTerm', {
+            bubbles: false,
+            cancelable: false,
+            detail: { term },
+        }));
+    }
+    setSearchQueryReplacement(query, newQuery) {
+        document.dispatchEvent(new CustomEvent('inboxSDKsearchReplacementReady', {
+            bubbles: false,
+            cancelable: false,
+            detail: { query, newQuery },
+        }));
+    }
+    registerComposeRequestModifier(keyId, appId) {
+        const modifierId = new Date().getTime() + '_' + appId + '_' + Math.random();
+        const detail = { modifierId };
+        if (this.isUsingSyncAPI()) {
+            detail.draftID = keyId;
+        }
+        else {
+            detail.composeid = keyId;
+        }
+        document.dispatchEvent(new CustomEvent('inboxSDKregisterComposeRequestModifier', {
+            detail,
+            bubbles: false,
+            cancelable: false,
+        }));
+        return modifierId;
+    }
+    unregisterComposeRequestModifier(keyId, modifierId) {
+        document.dispatchEvent(new CustomEvent('inboxSDKunregisterComposeRequestModifier', {
+            detail: { keyId, modifierId },
+            bubbles: false,
+            cancelable: false,
+        }));
+    }
+    modifyComposeRequest(keyId, modifierId, composeParams) {
+        const detail = { modifierId, composeParams };
+        if (this.isUsingSyncAPI())
+            detail.draftID = keyId;
+        else
+            detail.composeid = keyId;
+        document.dispatchEvent(new CustomEvent('inboxSDKcomposeRequestModified', {
+            detail,
+            bubbles: false,
+            cancelable: false,
+        }));
+    }
+}