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

package/src/common/quoted-split.js

@@ -0,0 +1,18 @@
+// Splits a string on spaces, but ignores spaces inside quotes.
+export default function quotedSplit(s) {
+    let split = [];
+    let lastEnd = 0;
+    const quoteRe = /"[^"]*"/g;
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+        const match = quoteRe.exec(s);
+        split = split.concat((match ? s.substring(lastEnd, match.index) : s.substring(lastEnd))
+            .split(/ +/)
+            .filter(Boolean));
+        if (!match)
+            break;
+        lastEnd = match.index + match[0].length;
+        split.push(match[0]);
+    }
+    return split;
+}

package/src/common/rate-limit-queuer.js

@@ -0,0 +1,57 @@
+// Returns a wrapped version of the function which queues up callTimestamps to the
+// function if it is called more than count times within period amount of time.
+export default function rateLimitQueuer(fn, period, count) {
+    let callTimestamps = [];
+    const queue = [];
+    let runningQueue = false;
+    function runJob() {
+        const job = queue.shift();
+        job();
+        if (queue.length) {
+            runQueue();
+        }
+        else {
+            runningQueue = false;
+        }
+    }
+    function runQueue() {
+        runningQueue = true;
+        const timeToWait = getTimeToUnqueueItem();
+        if (timeToWait > 0) {
+            setTimeout(runJob, timeToWait);
+        }
+        else {
+            runJob();
+        }
+    }
+    function getTimeToUnqueueItem() {
+        const now = Date.now();
+        const periodAgo = now - period;
+        callTimestamps = callTimestamps.filter((time) => time > periodAgo);
+        if (callTimestamps.length >= count) {
+            return callTimestamps[0] - periodAgo;
+        }
+        return -1;
+    }
+    return function attempt(...args) {
+        let job;
+        const promise = new Promise((resolve, reject) => {
+            job = () => {
+                callTimestamps.push(Date.now());
+                try {
+                    resolve(fn.apply(this, args));
+                }
+                catch (err) {
+                    reject(err);
+                }
+            };
+        });
+        if (!job)
+            throw new Error('Should not happen');
+        queue.push(job);
+        if (!runningQueue) {
+            runQueue();
+        }
+        return promise;
+    };
+}

package/src/common/rate-limit.js

@@ -0,0 +1,14 @@
+// Returns a wrapped version of the function which throws an exception if it's
+// called more than count times within period amount of time.
+export default function rateLimit(fn, period, count) {
+    let calls = [];
+    return function (...args) {
+        const now = Date.now();
+        calls = calls.filter((time) => time > now - period);
+        if (calls.length >= count) {
+            throw new Error('Function rate limit exceeded');
+        }
+        calls.push(now);
+        return fn.apply(this, args);
+    };
+}

package/src/common/version.js

@@ -0,0 +1,6 @@
+// This is in its own file so that updates to the version value don't cause a
+// reload of everything.
+export const BUILD_VERSION = process.env.VERSION;
+if (module.hot) {
+    module.hot.accept();
+}

package/src/inboxsdk-js/loading/platform-implementation-loader.js

@@ -0,0 +1,27 @@
+import once from 'lodash/once';
+import loadScript from '../../common/load-script';
+const PlatformImplementationLoader = {
+    load(appId, opts) {
+        return Promise.resolve()
+            .then(() => {
+            if (!global.__InboxSDKImpLoader) {
+                return PlatformImplementationLoader._loadScript().then(() => {
+                    if (!global.__InboxSDKImpLoader) {
+                        throw new Error('Implementation file did not load correctly');
+                    }
+                });
+            }
+        })
+            .then(() => global.__InboxSDKImpLoader.load('0.1', appId, opts));
+    },
+    _loadScript: once(function () {
+        return loadScript(process.env.IMPLEMENTATION_URL, {
+            nowrap: true, // platform-implementation has no top-level vars so no need for function wrapping
+        });
+    }),
+    preload() {
+        // Prime the load by calling it and letting the promise be memoized.
+        PlatformImplementationLoader._loadScript();
+    },
+};
+export default PlatformImplementationLoader;

package/src/injected-js/gmail/constants.js

@@ -0,0 +1,2 @@
+export const SEND_ACTIONS = ['^pfg'];
+export const DRAFT_SAVING_ACTIONS = ['^r', '^r_bt'];

package/src/injected-js/gmail/modify-suggestions.js

@@ -0,0 +1,106 @@
+import escape from 'lodash/escape';
+import autoHtml from 'auto-html';
+import { defn } from 'ud';
+import htmlToText from '../../common/html-to-text';
+import * as GRP from '../../platform-implementation-js/dom-driver/gmail/gmail-response-processor';
+/*
+Notes about the Gmail suggestions response:
+The response may be made up of multiple sections. Each section can specify
+results. There are three types of results: search terms/contacts, drive files,
+and emails. Each section may only contain one type of result. The sections can
+be in any order, though Gmail appears to always put the search terms/contacts
+section first.
+
+Some fields of a section:
+0: The constant "aso.srp"
+1: The user's search query
+3: Array of search term/contact suggestions.
+4: Array of email suggestions.
+5: Array of drive suggestions.
+6-9: Constants signifying type of section(?)
+  search terms/contacts: 1,0,0,1
+  drive:                 0,0,1,3
+  email:                 0,1,0,2
+11: Timestamp in microseconds. Each section should have the same timestamp.
+12: Typing autocomplete value or empty array.
+13: The length of the user's search query times 4 then cast to a string.
+
+Currently modifySuggestions modifies the first section and adds the
+app-provided suggestions into the search term/contact suggestions array.
+*/
+function modifySuggestions(responseText, modifications) {
+    const { value: parsed, options } = GRP.deserialize(responseText);
+    const query = parsed[0][1];
+    for (const modification of modifications) {
+        let name, nameHTML;
+        if (typeof modification.name === 'string') {
+            name = modification.name;
+            nameHTML = escape(name);
+        }
+        else if (typeof modification.nameHTML === 'string') {
+            nameHTML = modification.nameHTML;
+            name = htmlToText(nameHTML);
+        }
+        if (name == null || nameHTML == null) {
+            throw new Error('name or nameHTML must be provided');
+        }
+        let description, descriptionHTML;
+        if (typeof modification.description === 'string') {
+            description = modification.description;
+            descriptionHTML = escape(description);
+        }
+        else if (typeof modification.descriptionHTML === 'string') {
+            descriptionHTML = modification.descriptionHTML;
+            description = htmlToText(descriptionHTML);
+        }
+        const data = {
+            id: modification.id,
+            routeName: modification.routeName,
+            routeParams: modification.routeParams,
+            externalURL: modification.externalURL,
+        };
+        nameHTML += autoHtml ` <span style="display:none" data-inboxsdk-suggestion="${JSON.stringify(data)}"></span>`;
+        if (modification.iconHTML != null) {
+            nameHTML = `<div class="inboxsdk__custom_suggestion_iconHTML">${modification.iconHTML}</div>${nameHTML}`;
+        }
+        const newItem = [
+            'aso.sug',
+            modification.searchTerm || query,
+            nameHTML,
+            null,
+            [],
+            // screen height estimate. Currently Gmail bugs out if the screen height
+            // estimates add up to above the screen height, so let's avoid making the
+            // issue more likely by telling it our entries are zero-height.
+            0,
+            null,
+            'asor inboxsdk__custom_suggestion ' +
+                modification.providerId +
+                ' ' +
+                (modification.iconClass || ''),
+            0,
+        ];
+        if (descriptionHTML != null) {
+            newItem[3] = ['aso.eme', description, name, descriptionHTML, nameHTML];
+        }
+        // Allow iconHtml to be passed, and ignore iconUrl if iconHtml is presents
+        if (modification.iconHTML != null) {
+            // set empty image
+            newItem[6] = [
+                'aso.thn',
+                'data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==',
+            ];
+            newItem[7] += ' inboxsdk__no_bg';
+        }
+        else if (modification.iconUrl) {
+            newItem[6] = ['aso.thn', modification.iconUrl];
+            newItem[7] += ' inboxsdk__no_bg';
+        }
+        else {
+            newItem[7] += ' asor_i4';
+        }
+        parsed[0][3].push(newItem);
+    }
+    return GRP.serialize(parsed, options);
+}
+export default defn(module, modifySuggestions);

package/src/injected-js/gmail/setup-gmonkey-handler.js

@@ -0,0 +1,49 @@
+export default function setupGmonkeyHandler() {
+    const gmonkeyPromise = setupGmonkey();
+    document.addEventListener('inboxSDKtellMeIsConversationViewDisabled', function () {
+        gmonkeyPromise.then((gmonkey) => {
+            const answer = gmonkey.isConversationViewDisabled();
+            const event = document.createEvent('CustomEvent');
+            event.initCustomEvent('inboxSDKgmonkeyResponse', false, false, answer);
+            document.dispatchEvent(event);
+        });
+    });
+    document.addEventListener('inboxSDKtellMeCurrentThreadId', function (event) {
+        let threadId;
+        if (event.detail.isPreviewedThread) {
+            const rows = Array.from(document.querySelectorAll('[gh=tl] tr.aps'));
+            if (rows.length > 0) {
+                const elementWithId = rows
+                    .map((row) => row.querySelector('[data-thread-id]'))
+                    .filter(Boolean)[0];
+                if (elementWithId) {
+                    threadId = elementWithId.getAttribute('data-thread-id');
+                }
+                else {
+                    threadId = rows[0].getAttribute('data-inboxsdk-threadid');
+                }
+            }
+        }
+        else {
+            threadId = window.gmonkey?.v2?.getCurrentThread?.()?.getThreadId();
+        }
+        if (threadId) {
+            // hash is included in the sync id route url, so we also need to take it out
+            threadId = threadId.replace('#', '');
+            event.target.setAttribute('data-inboxsdk-currentthreadid', threadId);
+        }
+    });
+}
+function setupGmonkey() {
+    return new Promise((resolve) => {
+        function check() {
+            if (!window.gmonkey) {
+                setTimeout(check, 500);
+            }
+            else {
+                window.gmonkey.load('2.0', resolve);
+            }
+        }
+        check();
+    });
+}

package/src/injected-js/gmail/sync-compose-processor-20220909.js

@@ -0,0 +1,298 @@
+import sortBy from 'lodash/sortBy';
+import intersection from 'lodash/intersection';
+import isNotNil from '../../platform-implementation-js/lib/isNotNil';
+import { DRAFT_SAVING_ACTIONS, SEND_ACTIONS, } from './constants';
+const ACTION_TYPE_PRIORITY_RANK = [
+    'SEND',
+    'DRAFT_SAVE',
+];
+export function parseComposeRequestBody_2022_09_09(request) {
+    return parseCreateUpdateSendDraftRequestBody(request);
+}
+export function parseComposeResponseBody_2022_09_09(response) {
+    return parseCreateUpdateSendDraftResponseBody(response);
+}
+export function replaceBodyContentInComposeSendRequestBody_2022_09_09(request, newBodyHtmlContent) {
+    return replaceBodyContentInSendRequestBody(request, newBodyHtmlContent);
+}
+/**
+ * Parses request body when compose window either saves a draft for the first time,
+ * updates the draft or sends the draft.
+ * NOTE: request could contain multiple threads and messages within it,
+ * prioritize SEND to DRAFT_SAVE message.
+ */
+function parseCreateUpdateSendDraftRequestBody(request) {
+    const updateList = request[1]?.[0];
+    if (!Array.isArray(updateList)) {
+        // cannot parse
+        return null;
+    }
+    const parsedMessages = updateList.map(parseRequestThread).filter(isNotNil);
+    const sorted = sortBy(parsedMessages, (m) => ACTION_TYPE_PRIORITY_RANK.indexOf(m.type));
+    return sorted[0] || null;
+}
+/**
+ * Parses response body when compose window either saved a draft for the first time,
+ * updated the draft, or sent the draft.
+ * NOTE: response could contain multiple threads and messages within it
+ * even not related to a message/thread in the request body.
+ * So the calling code should find needed message manually.
+ */
+function parseCreateUpdateSendDraftResponseBody(response) {
+    const updateList = response[1]?.[5];
+    if (!Array.isArray(updateList)) {
+        // cannot parse
+        return [];
+    }
+    return updateList
+        .map(parseResponseThread)
+        .filter(isNotNil)
+        .flatMap((parsedThread) => {
+        const { threadId, oldThreadId, parsedMessages } = parsedThread;
+        return parsedMessages.map((parsedMessage) => {
+            const { messageId, to, cc, bcc, actions, rfcID, oldMessageId } = parsedMessage;
+            const actionType = actionsToComposeRequestType(actions);
+            if (!actionType) {
+                // unsupported actions within a message
+                return null;
+            }
+            return {
+                threadId,
+                messageId,
+                to,
+                cc,
+                bcc,
+                actions,
+                rfcID,
+                oldMessageId,
+                oldThreadId,
+                type: actionType,
+            };
+        });
+    })
+        .filter(isNotNil);
+}
+function replaceBodyContentInSendRequestBody(request, newBodyHtmlContent) {
+    // since draftID is not passed from outside,
+    // use parse function to find a message which body needs to be replaced
+    const parsed = parseCreateUpdateSendDraftRequestBody(request);
+    if (!parsed) {
+        return null;
+    }
+    const replaceBodyInThisMessageId = parsed.messageId;
+    const updateList = request[1]?.[0];
+    if (!Array.isArray(updateList)) {
+        // cannot parse
+        return null;
+    }
+    for (const threadWrapper of updateList) {
+        if (!Array.isArray(threadWrapper) || !Array.isArray(threadWrapper[1])) {
+            // cannot parse
+            return null;
+        }
+        const thread = threadWrapper[1];
+        const threadId = parseThreadId(thread[0]);
+        if (!threadId) {
+            // cannot parse
+            return null;
+        }
+        const parseResult = findAndParseRequestMessage(thread);
+        if (parseResult?.parsedMsg.messageId === replaceBodyInThisMessageId) {
+            const actionType = actionsToComposeRequestType(parseResult.parsedMsg.actions);
+            if (actionType === 'SEND') {
+                // find first message with needed messageId and 'SEND' action and replace the body content
+                replaceBodyInRequestMsg(parseResult.originalMsg, newBodyHtmlContent);
+                return request;
+            }
+        }
+    }
+    return null;
+}
+function parseThreadId(threadId) {
+    if (!threadId.startsWith('thread-')) {
+        return null;
+    }
+    if (threadId.includes('|')) {
+        return threadId.split('|')[0];
+    }
+    return threadId;
+}
+function parseMsgId(messageId) {
+    if (!messageId.startsWith('msg-')) {
+        // cannot parse
+        return null;
+    }
+    return messageId;
+}
+function parseContacts(contacts) {
+    if (!Array.isArray(contacts)) {
+        // cannot parse
+        return null;
+    }
+    return contacts
+        .filter((c) => !!c[1])
+        .map((c) => ({ emailAddress: c[1], name: c[2] ?? null }));
+}
+function findAndParseRequestMessage(thread) {
+    const originalMsgs = [
+        thread[1]?.[2]?.[0]?.[4]?.[0],
+        thread[1]?.[1]?.[0],
+        thread[1]?.[13]?.[0],
+    ];
+    for (const originalMsg of originalMsgs) {
+        const parsedMsg = parseRequestMsg(originalMsg);
+        if (parsedMsg) {
+            return { parsedMsg, originalMsg };
+        }
+    }
+    return null;
+}
+function parseRequestThread(threadWrapper) {
+    if (!Array.isArray(threadWrapper) || !Array.isArray(threadWrapper[1])) {
+        // cannot parse
+        return null;
+    }
+    const thread = threadWrapper[1];
+    const threadId = parseThreadId(thread[0]);
+    if (!threadId) {
+        // cannot parse
+        return null;
+    }
+    const parseResult = findAndParseRequestMessage(thread);
+    if (!parseResult) {
+        // cannot parse
+        return null;
+    }
+    const { parsedMsg: message, originalMsg } = parseResult;
+    const { messageId, to, cc, bcc, subject, body, actions } = message;
+    let actionType = actionsToComposeRequestType(actions);
+    if (!actionType) {
+        // exit if doesn't have required actions
+        return null;
+    }
+    // usually for draft_save action when draft or reply got saved for first time, response could be different
+    // from usual update response, so replace draft_save action with first_draft_save in this case.
+    if (actionType === 'DRAFT_SAVE' &&
+        (originalMsg === thread[1]?.[2]?.[0]?.[4]?.[0] ||
+            originalMsg === thread[1]?.[1]?.[0])) {
+        actionType = 'FIRST_DRAFT_SAVE';
+    }
+    return {
+        threadId,
+        messageId,
+        to,
+        cc,
+        bcc,
+        subject,
+        body,
+        actions,
+        type: actionType,
+    };
+}
+function parseRequestMsg(msg) {
+    if (!Array.isArray(msg)) {
+        // cannot parse
+        return null;
+    }
+    const messageId = parseMsgId(msg[0]);
+    if (!messageId) {
+        // cannot parse
+        return null;
+    }
+    const subject = msg[7];
+    const to = parseContacts(msg[2]);
+    const cc = parseContacts(msg[3]);
+    const bcc = parseContacts(msg[4]);
+    const body = msg[8][1][0][1];
+    const actions = msg[10];
+    const rfcID = msg[13];
+    const oldMessageId = msg[55];
+    return {
+        messageId,
+        to,
+        cc,
+        bcc,
+        subject,
+        body,
+        actions,
+        rfcID,
+        oldMessageId,
+    };
+}
+function replaceBodyInRequestMsg(msg, newBodyHtmlContent) {
+    if (!Array.isArray(msg)) {
+        // cannot parse
+        return null;
+    }
+    msg[8][1][0][1] = newBodyHtmlContent;
+}
+function parseResponseThread(threadWrapper) {
+    if (!Array.isArray(threadWrapper) || !Array.isArray(threadWrapper[0])) {
+        // cannot parse
+        return null;
+    }
+    const thread = threadWrapper[0];
+    const threadId = parseThreadId(thread[0]);
+    if (!threadId) {
+        // cannot parse
+        return null;
+    }
+    const threadInner = thread[2]?.[6]?.[0];
+    if (!Array.isArray(threadInner)) {
+        // cannot parse
+        return null;
+    }
+    const oldThreadId = threadInner[19];
+    const parsedMessages = Array.isArray(threadInner[4])
+        ? threadInner[4]
+            .map((msg) => {
+            if (!Array.isArray(msg)) {
+                // cannot parse
+                return null;
+            }
+            return parseResponseMsg(msg);
+        })
+            .filter(isNotNil)
+        : [];
+    return {
+        threadId,
+        oldThreadId,
+        parsedMessages,
+    };
+}
+function parseResponseMsg(msg) {
+    if (!Array.isArray(msg)) {
+        // cannot parse
+        return null;
+    }
+    const messageId = parseMsgId(msg[0]);
+    if (!messageId) {
+        // cannot parse
+        return null;
+    }
+    const actions = msg[10];
+    const to = parseContacts(msg[2]);
+    const cc = parseContacts(msg[3]);
+    const bcc = parseContacts(msg[4]);
+    const rfcID = msg[13];
+    const oldMessageId = msg[55];
+    return {
+        messageId,
+        to,
+        cc,
+        bcc,
+        actions,
+        rfcID,
+        oldMessageId,
+    };
+}
+export function actionsToComposeRequestType(actions) {
+    if (intersection(actions, DRAFT_SAVING_ACTIONS).length ===
+        DRAFT_SAVING_ACTIONS.length) {
+        return 'DRAFT_SAVE';
+    }
+    if (intersection(actions, SEND_ACTIONS).length === SEND_ACTIONS.length) {
+        return 'SEND';
+    }
+    return null;
+}

package/src/injected-js/gmail/sync-compose-processor.js

@@ -0,0 +1,55 @@
+import { parseComposeRequestBody_2022_09_09, parseComposeResponseBody_2022_09_09, replaceBodyContentInComposeSendRequestBody_2022_09_09, } from './sync-compose-processor-20220909';
+import { getDetailsOfComposeRequest, replaceEmailBodyForSendRequest, } from './sync-compose-request-processor';
+import * as logger from '../injected-logger';
+export function parseComposeRequestBody(request) {
+    const requestParsed = JSON.parse(request);
+    try {
+        if (Array.isArray(requestParsed)) {
+            const parsed = parseComposeRequestBody_2022_09_09(requestParsed);
+            if (parsed) {
+                return {
+                    type: parsed.type,
+                    to: parsed.to,
+                    cc: parsed.cc,
+                    bcc: parsed.bcc,
+                    draftID: parsed.messageId.replace('msg-a:', ''),
+                    subject: parsed.subject,
+                    body: parsed.body,
+                };
+            }
+            return null;
+        }
+    }
+    catch (err) {
+        logger.eventSdkPassive('connection.requestResponseParsingFailed', {
+            requestParseError: err,
+        });
+    }
+    return getDetailsOfComposeRequest(requestParsed);
+}
+export function parseComposeResponseBody(response) {
+    const responseParsed = JSON.parse(response);
+    if (Array.isArray(responseParsed)) {
+        return parseComposeResponseBody_2022_09_09(responseParsed);
+    }
+    return [];
+}
+export function replaceBodyContentInComposeSendRequestBody(request, newBodyHtmlContent) {
+    const requestParsed = JSON.parse(request);
+    try {
+        if (Array.isArray(requestParsed)) {
+            const replacedRequestObj = replaceBodyContentInComposeSendRequestBody_2022_09_09(requestParsed, newBodyHtmlContent);
+            if (replacedRequestObj) {
+                return JSON.stringify(replacedRequestObj);
+            }
+            // if couldn't parse and replace body content, return original object
+            return request;
+        }
+    }
+    catch (err) {
+        logger.eventSdkPassive('connection.requestResponseParsingFailed', {
+            replaceBodyFailed: err,
+        });
+    }
+    return replaceEmailBodyForSendRequest(request, newBodyHtmlContent);
+}