{
{
- if (event.target instanceof HTMLElement && event.target.closest('[data-slate-editor]'))
+ // Drags that start inside the Slate editor (moving an inline image, say)
+ // are Slate's to manage - it sets the drop effect and shows a caret, and
+ // preventing the default here would hide it. Anything we've said we'll
+ // accept still needs preventDefault, even over the editor: a
+ // contenteditable refuses drags it has no way to insert - like a dragged
+ // thread, which carries only our own dataTransfer types - so without it
+ // no drop event ever fires in the middle of the composer.
+ if (
+ event.target instanceof HTMLElement &&
+ event.target.closest('[data-slate-editor]') &&
+ !this.props.shouldAcceptDrop(event)
+ ) {
return;
+ }
const allowed = event.dataTransfer.effectAllowed;
if (allowed && allowed !== 'all' && allowed !== 'uninitialized') {
// Only set dropEffect if it's a valid value (not 'all' or 'uninitialized')
diff --git a/app/src/drag-drop-types.ts b/app/src/drag-drop-types.ts
new file mode 100644
index 0000000000..89a8bb1981
--- /dev/null
+++ b/app/src/drag-drop-types.ts
@@ -0,0 +1,20 @@
+/**
+ * Custom dataTransfer types used for drag and drop within the app.
+ *
+ * A drop target can only read `dataTransfer.types` during dragenter/dragover —
+ * the payload itself isn't readable until the drop lands. That's why the
+ * account ids are encoded into a type name rather than the payload: a target
+ * that can only accept threads from certain accounts has to decide before it
+ * can call getData.
+ */
+
+/** JSON `{ threadIds, accountIds }`, set when threads are dragged. */
+export const ThreadsDragType = 'mailspring-threads-data';
+
+/** Prefix of a value-less type carrying the dragged threads' account ids. */
+export const AccountsDragTypePrefix = 'mailspring-accounts=';
+
+export function accountIdsForDragTypes(types: readonly string[]): string[] {
+ const accountsType = types.find((t) => t.startsWith(AccountsDragTypePrefix));
+ return (accountsType || '').replace(AccountsDragTypePrefix, '').split(',');
+}
diff --git a/app/src/global/mailspring-exports.d.ts b/app/src/global/mailspring-exports.d.ts
index 35c19467dd..7cac21fc0c 100644
--- a/app/src/global/mailspring-exports.d.ts
+++ b/app/src/global/mailspring-exports.d.ts
@@ -204,6 +204,8 @@ export type FsUtils = typeof import('../fs-utils');
export const FsUtils: FsUtils;
export type CanvasUtils = typeof import('../canvas-utils');
export const CanvasUtils: CanvasUtils;
+export type DragDropTypes = typeof import('../drag-drop-types');
+export const DragDropTypes: DragDropTypes;
export type RegExpUtils = typeof import('../regexp-utils').default;
export const RegExpUtils: RegExpUtils;
export type MenuHelpers = typeof import('../menu-helpers');
diff --git a/app/src/global/mailspring-exports.js b/app/src/global/mailspring-exports.js
index bcbdf36df7..10a532749b 100644
--- a/app/src/global/mailspring-exports.js
+++ b/app/src/global/mailspring-exports.js
@@ -187,6 +187,7 @@ lazyLoad(`CalendarUtils`, 'calendar-utils');
lazyLoad(`ICSEventHelpers`, 'ics-event-helpers');
lazyLoad(`FsUtils`, 'fs-utils');
lazyLoad(`CanvasUtils`, 'canvas-utils');
+lazyLoad(`DragDropTypes`, 'drag-drop-types');
lazyLoad(`RegExpUtils`, 'regexp-utils');
lazyLoad(`MenuHelpers`, 'menu-helpers');
lazyLoad(`VirtualDOMUtils`, 'virtual-dom-utils');
diff --git a/app/src/services/eml-utils.ts b/app/src/services/eml-utils.ts
index a21b0cecda..4ca63cf7b9 100644
--- a/app/src/services/eml-utils.ts
+++ b/app/src/services/eml-utils.ts
@@ -1,3 +1,17 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import crypto from 'crypto';
+import _ from 'underscore';
+
+import {
+ Actions,
+ DatabaseStore,
+ Message,
+ TaskQueue,
+ GetMessageRFC2822Task,
+} from 'mailspring-exports';
+
/**
* Generate a safe default .eml filename from a message subject.
*
@@ -19,3 +33,163 @@ export function defaultEmlFilename(subject: string): string {
name = name.replace(/[.\s]+$/, '');
return `${name}.eml`;
}
+
+export interface StagedEml {
+ message: Message;
+ filePath: string;
+}
+
+/**
+ * Resolve the message that represents each of the given threads for the
+ * purposes of .eml export.
+ *
+ * .eml holds a single RFC2822 message, so a thread has to be narrowed to one.
+ * Everywhere in the app we use the same convention: the most recent message in
+ * the thread. Drafts are skipped — they only exist locally, so the sync engine
+ * has no raw source to hand back for them.
+ *
+ * Threads with no exportable message are omitted, so the result may be shorter
+ * than `threadIds`.
+ */
+export async function newestExportableMessagesForThreadIds(
+ threadIds: string[]
+): Promise {
+ if (!threadIds.length) {
+ return [];
+ }
+ const messages = await Promise.all(
+ threadIds.map(async (threadId) => {
+ const found = await DatabaseStore.findAll(Message, { threadId, draft: false })
+ .order(Message.attributes.date.descending())
+ .limit(1);
+ return found.length ? found[0] : null;
+ })
+ );
+ return messages.filter((m) => m !== null);
+}
+
+/**
+ * Ask the sync engine for the raw RFC2822 source of each message and write it
+ * to a temporary .eml file on disk.
+ *
+ * Each message is staged into its own randomly named subdirectory so that
+ * concurrent stages of the same message can't overwrite one another, and so
+ * that the file basename can be a clean, human-readable name (it becomes the
+ * attachment's display name when the file is attached to a draft). By default
+ * the name comes from the subject; pass `filename` to override it.
+ *
+ * The fetch is remote, so it may fail — and a GetMessageRFC2822Task can reach
+ * `complete` without having written anything. Messages whose file never
+ * appeared are omitted from the result, so callers should compare the returned
+ * length against what they passed in to detect partial failures.
+ */
+export async function stageMessagesAsEml(
+ messages: Message[],
+ { filename }: { filename?: string } = {}
+): Promise {
+ if (!messages.length) {
+ return [];
+ }
+
+ const staged = messages.map((message) => {
+ const token = crypto.randomBytes(4).toString('hex');
+ const dir = path.join(os.tmpdir(), `mailspring-eml-${message.id}-${token}`);
+ const basename = filename || defaultEmlFilename(message.subject);
+ return { message, dir, filePath: path.join(dir, basename) };
+ });
+
+ // Queue every fetch before awaiting any of them so a multi-message stage
+ // isn't serialized on the sync engine's round trips.
+ const tasks = staged.map(({ message, dir, filePath }) => {
+ fs.mkdirSync(dir, { recursive: true });
+ const task = new GetMessageRFC2822Task({
+ messageId: message.id,
+ accountId: message.accountId,
+ filepath: filePath,
+ });
+ Actions.queueTask(task);
+ return task;
+ });
+
+ await Promise.all(tasks.map((task) => TaskQueue.waitForPerformRemote(task)));
+
+ // Directories whose file never arrived are dead weight — drop them now, and
+ // leave the rest to discardStagedEml once the caller is done with the file.
+ const [written, missing] = _.partition(staged, ({ filePath }) => fs.existsSync(filePath));
+ missing.forEach(({ dir }) => removeStagingDirectory(dir));
+
+ return written.map(({ message, filePath }) => ({ message, filePath }));
+}
+
+/**
+ * Stage a single message, returning null if its source couldn't be fetched.
+ */
+export async function stageMessageAsEml(
+ message: Message,
+ options: { filename?: string } = {}
+): Promise {
+ const [staged] = await stageMessagesAsEml([message], options);
+ return staged || null;
+}
+
+/**
+ * Stage the message that represents a single thread, returning null if the
+ * thread has nothing exportable in it or its source couldn't be fetched.
+ */
+export async function stageThreadAsEml(
+ threadId: string,
+ options: { filename?: string } = {}
+): Promise {
+ const [message] = await newestExportableMessagesForThreadIds([threadId]);
+ return message ? stageMessageAsEml(message, options) : null;
+}
+
+/**
+ * Delete a file produced by stageMessagesAsEml, along with the staging
+ * directory it lives in.
+ *
+ * Staged files are consumed by copying them somewhere permanent — attaching
+ * one to a draft copies it into the attachment store — so the temporary copy
+ * is garbage the moment the caller is finished with it. Callers should invoke
+ * this once that's true (for attachments, from `addAttachment`'s `onCreated`).
+ * Failures are ignored: leaving a file behind in the temp directory is not
+ * worth interrupting the user over.
+ */
+export function discardStagedEml(filePath: string) {
+ removeStagingDirectory(path.dirname(filePath));
+}
+
+const STAGING_DIR_PREFIX = 'mailspring-eml-';
+
+function removeStagingDirectory(dir: string) {
+ // Guard against deleting anything we didn't create ourselves — callers hand
+ // us paths, and a wrong one shouldn't take a real directory with it.
+ if (!path.basename(dir).startsWith(STAGING_DIR_PREFIX)) {
+ return;
+ }
+ try {
+ fs.rmSync(dir, { recursive: true, force: true });
+ } catch (err) {
+ // best effort
+ }
+}
+
+export interface StagedThreads {
+ staged: StagedEml[];
+ /**
+ * Threads that hold nothing exportable — a conversation containing only
+ * unsent drafts, say. Nothing was fetched for these, so they're a distinct
+ * outcome from a fetch that was attempted and failed.
+ */
+ unavailableThreadIds: string[];
+}
+
+/**
+ * Convenience wrapper over the two steps above: turn a set of thread ids into
+ * staged .eml files ready to be attached to a draft.
+ */
+export async function stageThreadsAsEml(threadIds: string[]): Promise {
+ const messages = await newestExportableMessagesForThreadIds(threadIds);
+ const unavailableThreadIds = threadIds.filter((id) => !messages.some((m) => m.threadId === id));
+ return { staged: await stageMessagesAsEml(messages), unavailableThreadIds };
+}