50:I[707087,["/_next/static/immutable/chunks/3arlv5bvukoo2.js","/_next/static/immutable/chunks/39v64hmfyo-sr.js","/_next/static/immutable/chunks/2nvof3-29tvc3.js","/_next/static/immutable/chunks/3tjobt77z_9dj.js","/_next/static/immutable/chunks/04j_o97cgxn2x.js","/_next/static/immutable/chunks/3upr08c9vtj8w.js","/_next/static/immutable/chunks/1ww0328si-u8x.js","/_next/static/immutable/chunks/11mfl5ymqld9-.js","/_next/static/immutable/chunks/2xxcqy6ppds3l.js","/_next/static/immutable/chunks/3j06ow7w40nxu.js","/_next/static/immutable/chunks/31nn7jwsjvqii.js","/_next/static/immutable/chunks/43_s7jweyypoh.js","/_next/static/immutable/chunks/0p6vao205o1jc.js","/_next/static/immutable/chunks/1_kyvgkyokw92.js","/_next/static/immutable/chunks/1lo-zn37dolb5.js","/_next/static/immutable/chunks/1v8k6yxw1rg0u.js"],"RegistryDependencies"] 51:I[314491,["/_next/static/immutable/chunks/3arlv5bvukoo2.js","/_next/static/immutable/chunks/39v64hmfyo-sr.js","/_next/static/immutable/chunks/2nvof3-29tvc3.js","/_next/static/immutable/chunks/3tjobt77z_9dj.js","/_next/static/immutable/chunks/04j_o97cgxn2x.js","/_next/static/immutable/chunks/3upr08c9vtj8w.js","/_next/static/immutable/chunks/1ww0328si-u8x.js","/_next/static/immutable/chunks/11mfl5ymqld9-.js","/_next/static/immutable/chunks/2xxcqy6ppds3l.js","/_next/static/immutable/chunks/3j06ow7w40nxu.js","/_next/static/immutable/chunks/31nn7jwsjvqii.js","/_next/static/immutable/chunks/43_s7jweyypoh.js","/_next/static/immutable/chunks/0p6vao205o1jc.js","/_next/static/immutable/chunks/1_kyvgkyokw92.js","/_next/static/immutable/chunks/1lo-zn37dolb5.js","/_next/static/immutable/chunks/1v8k6yxw1rg0u.js"],"FilesView"] 52:T3ae6,"use client"; import * as React from "react"; import { FileText, Layers3, Mail, Paperclip } from "lucide-react"; import { cn } from "@/lib/utils"; import { useEmailInlineResourceUrls } from "./email-viewer-inline-resources"; import { buildMimeTree, deriveEmailInlineResourceScope, deriveEmailViewerModel, findMimeNodeByPath, getDefaultMimeSelectionPath, } from "./email-viewer-model"; import type { EmailAddress, EmailContentModel, EmailHeaderModel, EmailSidebarItem, EmailSidebarModel, EmailViewerMessage, EmailViewerModel, EmailViewerProps, EmailViewerProviderProps, MimePartNode, MimePartPath, } from "./email-viewer-types"; import { FileThumbnail } from "./file-thumbnail"; import { FileViewerPreview } from "./file-viewer"; import { ViewerBody, ViewerHeader, ViewerRoot, ViewerSidebar, ViewerSidebarTrigger, ViewerSurface, } from "./viewer"; import { useKeyedMountEffect } from "@/hooks/use-keyed-mount-effect"; import { joinEffectKey } from "@/lib/effect-key"; export type { EmailAddress, EmailAttachmentSidebarItem, EmailBodySelectionPolicy, EmailBodySidebarItem, EmailContentEmpty, EmailContentEmptyReason, EmailContentFile, EmailContentModel, EmailContentNestedMessage, EmailFilePayload, EmailHeaderModel, EmailInlineResource, EmailInlineResourceKey, EmailInlineResourceScope, EmailSidebarItemBase, EmailSidebarItem, EmailSidebarModel, EmailSidebarSection, EmailSidebarThumbnailModel, EmailViewerMessage, EmailViewerModel, EmailViewerProviderProps, EmailViewerProps, MimeHeader, MimeMessage, MimeMessageScope, MimePart, MimePartDisposition, MimePartFacts, MimePartKind, MimePartNode, MimePartPath, MimePreviewPolicy, } from "./email-viewer-types"; export { EmailResourceContent, type EmailResourceContentProps, } from "./email-viewer-content"; export { parseEmlMessage, type ParseEmlOptions } from "./email-viewer-eml"; export { buildMimeTree, categoryForMimeNode, createMimeMessageScope, DEFAULT_EMAIL_BODY_SELECTION_POLICY, deriveEmailContentModel, deriveEmailHeaderModel, deriveEmailInlineResourceScope, deriveEmailSidebarModel, deriveEmailViewerModel, findMimeNodeByPath, getDefaultMimeSelectionPath, getInlineResourceScope, inlineResourceKeyToString, isAttachmentNode, isInlineResourceNode, isMessageNode, isMultipartNode, isRenderableNode, normalizeContentId, normalizeContentLocation, pathsEqual, replaceCidUrls, replaceInlineResourceUrls, } from "./email-viewer-model"; const DEFAULT_MAX_NESTED_MESSAGE_DEPTH = 8; type EmailViewerContextValue = { model: EmailViewerModel; selectPart: (node: MimePartNode) => void; }; type EmailViewerProviderInternalProps = EmailViewerProviderProps & { nestedMessageDepth?: number; }; type EmailViewerInternalProps = EmailViewerProps & { nestedMessageDepth?: number; }; type EmailViewerLayoutProps = Pick< EmailViewerInternalProps, "className" | "mode" >; const EmailViewerContext = React.createContext( null, ); function useEmailViewerContext() { const context = React.useContext(EmailViewerContext); if (!context) { throw new Error("EmailViewerProvider context is missing."); } return context; } function useEmailViewerHeaderState(): EmailHeaderModel { return useEmailViewerContext().model.header; } function useEmailViewerPartsSidebarState(): { sidebar: EmailSidebarModel; selectPart: (node: MimePartNode) => void; } { const { model, selectPart } = useEmailViewerContext(); return { sidebar: model.sidebar, selectPart, }; } function useEmailViewerContentState(): EmailContentModel { return useEmailViewerContext().model.content; } export function EmailViewerProvider(props: EmailViewerProviderProps) { return ; } function EmailViewerProviderInternal({ message, selectedPath, defaultSelectedPath, onSelectedPathChange, maxNestedMessageDepth = DEFAULT_MAX_NESTED_MESSAGE_DEPTH, nestedMessageDepth = 0, children, }: EmailViewerProviderInternalProps) { const rootNode = React.useMemo( () => buildMimeTree(message.root), [message.root], ); const defaultPath = React.useMemo( () => defaultSelectedPath && findMimeNodeByPath(rootNode, defaultSelectedPath) ? defaultSelectedPath : getDefaultMimeSelectionPath(rootNode), [defaultSelectedPath, rootNode], ); const [internalSelectedPath, setInternalSelectedPath] = React.useState(defaultPath); const controlled = selectedPath !== undefined; const activePath = controlled ? (selectedPath ?? defaultPath) : internalSelectedPath; const selectedNode = findMimeNodeByPath(rootNode, activePath) ?? findMimeNodeByPath(rootNode, defaultPath) ?? rootNode; const inlineResourceScope = React.useMemo( () => deriveEmailInlineResourceScope(rootNode, selectedNode), [rootNode, selectedNode], ); const inlineResourceUrls = useEmailInlineResourceUrls(inlineResourceScope); useKeyedMountEffect( joinEffectKey([controlled, defaultPath, internalSelectedPath, rootNode]), () => { if (controlled) return; if (findMimeNodeByPath(rootNode, internalSelectedPath)) return; setInternalSelectedPath(defaultPath); }, ); const selectPart = React.useCallback( (node: MimePartNode) => { if (!controlled) setInternalSelectedPath(node.path); onSelectedPathChange?.(node.path, node); }, [controlled, onSelectedPathChange], ); const model = React.useMemo( () => deriveEmailViewerModel({ inlineResourceUrls, maxNestedMessageDepth, message, nestedMessageDepth, rootNode, selectedNode, }), [ inlineResourceUrls, maxNestedMessageDepth, message, nestedMessageDepth, rootNode, selectedNode, ], ); const value = React.useMemo( () => ({ model, selectPart }), [model, selectPart], ); return ( {children} ); } export function EmailViewer(props: EmailViewerProps) { return ; } function EmailViewerInternal({ message, selectedPath, defaultSelectedPath, onSelectedPathChange, maxNestedMessageDepth, mode, nestedMessageDepth = 0, className, }: EmailViewerInternalProps) { if (nestedMessageDepth === 0) { return ( ); } return ( ); } function EmailViewerLayout({ className, mode }: EmailViewerLayoutProps) { return (

); } export function EmailViewerHeader({ trailing = , }: { trailing?: React.ReactNode; }) { return ( ); } export function EmailViewerPartsSidebar() { const { sidebar, selectPart } = useEmailViewerPartsSidebarState(); return ; } export function EmailViewerContent() { const content = useEmailViewerContentState(); if (content.kind === "nested-message") { return ( ); } if (content.kind === "empty") { return (

{content.message}

); } return ( ); } function MimeMessageHeader({ header, trailing, }: { header: EmailHeaderModel; trailing?: React.ReactNode; }) { const from = formatEmailAddresses(header.from); const to = formatEmailAddresses(header.to); return (

{header.subject}

{trailing}

{from ? From {from} : null} {to ? To {to} : null} {header.sentAt ? ( {header.sentAt} ) : null}

); } function MimePartSidebar({ sidebar, onSelectPart, className, }: { sidebar: EmailSidebarModel; onSelectPart: (node: MimePartNode) => void; className?: string; }) { return (

{sidebar.attachmentCount} attachment {sidebar.attachmentCount === 1 ? "" : "s"}

{sidebar.sections.map((section) => ( {section.items.length === 0 ? ( section.emptyLabel ? (

{section.emptyLabel}

) : null ) : (

))}

)} ))}

); } function formatEmailAddresses(addresses: readonly EmailAddress[]) { return addresses.map((address) => address.display).join(", ") || null; } function MimePartSidebarSection({ title, children, }: { title: string; children: React.ReactNode; }) { const titleId = React.useId(); return (

{title}

{children}

); } function MimePartSidebarItem({ item, onSelectPart, }: { item: EmailSidebarItem; onSelectPart: (node: MimePartNode) => void; }) { return (

); } function SidebarItemThumbnail({ item }: { item: EmailSidebarItem }) { if (item.thumbnail.kind === "file") { return ( ); } return ( ); } function PartIcon({ icon, className, }: { icon: "file" | "layers" | "mail" | "paperclip"; className?: string; }) { if (icon === "layers") return ; if (icon === "mail") return ; if (icon === "paperclip") { return ; } return ; } 53:T6aeb,import { detectCategory, type FileCategory, type ViewerSource, } from "@/lib/viewer-source"; import type { EmailAddress, EmailBodySelectionPolicy, EmailContentEmptyReason, EmailContentModel, EmailHeaderModel, EmailInlineResource, EmailInlineResourceKey, EmailInlineResourceScope, EmailSidebarItem, EmailSidebarModel, EmailSidebarThumbnailModel, EmailViewerMessage, EmailViewerModel, MimeMessage, MimeMessageScope, MimePart, MimePartFacts, MimePartKind, MimePartNode, MimePartPath, MimePreviewPolicy, } from "./email-viewer-types"; import { formatFileSize } from "./file-size-format"; const DEFAULT_EMPTY_CONTENT_MESSAGE = "This MIME part does not have a previewable body."; const DEFAULT_MAX_NESTED_MESSAGE_DEPTH = 8; const EMPTY_INLINE_RESOURCE_URLS = new Map(); export const MISSING_EMAIL_INLINE_RESOURCE_URL = "data:image/gif;base64,R0lGODlhAQABAAAAACw="; export const DEFAULT_EMAIL_BODY_SELECTION_POLICY = { preferredMimeTypes: ["text/html", "text/plain", "text/markdown"], includeInlineBodyParts: true, includeAttachments: false, } satisfies EmailBodySelectionPolicy; export function buildMimeTree(root: MimePart): MimePartNode { return buildMimeNode({ part: root, parentPath: null, depth: 0, pathPart: normalizePathPart(root.id, 0), }); } export function findMimeNodeByPath( root: MimePartNode, path: MimePartPath, ): MimePartNode | null { if (pathsEqual(root.path, path)) return root; for (const child of root.children) { const match = findMimeNodeByPath(child, path); if (match) return match; } return null; } export function getDefaultMimeSelectionPath(root: MimePartNode): MimePartPath { return (selectMimeScopeBodyNode(root) ?? root).path; } export function deriveEmailViewerModel({ inlineResourceUrls, maxNestedMessageDepth = DEFAULT_MAX_NESTED_MESSAGE_DEPTH, message, nestedMessageDepth = 0, rootNode, selectedNode, }: { inlineResourceUrls: ReadonlyMap; maxNestedMessageDepth?: number; message: EmailViewerMessage; nestedMessageDepth?: number; rootNode: MimePartNode; selectedNode: MimePartNode; }): EmailViewerModel { const scope = createMimeMessageScope(message, rootNode); const selectedPath = selectedNode.path; return { message, rootNode, scope, selectedPath, selectedNode, header: deriveEmailHeaderModel(message), sidebar: deriveEmailSidebarModel({ inlineResourceUrls, scope, selectedPath, }), content: deriveEmailContentModel({ inlineResourceUrls, maxNestedMessageDepth, message, nestedMessageDepth, selectedNode, }), }; } export function createMimeMessageScope( message: EmailViewerMessage, root: MimePartNode, ): MimeMessageScope { return { message, root, path: root.path, descendants: collectCurrentMessageNodes(root), }; } export function deriveEmailHeaderModel( message: EmailViewerMessage, ): EmailHeaderModel { return { subject: message.subject?.trim() || "(no subject)", from: normalizeAddressList(message.from), to: normalizeAddressList(message.to), cc: normalizeAddressList(message.cc), bcc: normalizeAddressList(message.bcc), sentAt: formatSentAt(message.sentAt), }; } export function deriveEmailSidebarModel({ inlineResourceUrls = EMPTY_INLINE_RESOURCE_URLS, scope, selectedPath, }: { inlineResourceUrls?: ReadonlyMap; scope: MimeMessageScope; selectedPath: MimePartPath; }): EmailSidebarModel { const bodyNode = selectMimeScopeBodyNode(scope.root); const bodyItems: readonly EmailSidebarItem[] = [ createSidebarItem({ inlineResourceUrls, kind: "body", node: bodyNode ?? scope.root, selectedPath, }), ]; const attachmentItems = scope.descendants .filter((node) => isEmailAttachmentSidebarNode(node, bodyNode)) .map((node) => createSidebarItem({ inlineResourceUrls, kind: "attachment", node, selectedPath, }), ); const sections = [ { id: "body" as const, title: "Body", items: bodyItems, }, { id: "attachments" as const, title: "Attachments", items: attachmentItems, emptyLabel: "No attachments.", }, ]; return { bodyCount: bodyItems.length, attachmentCount: attachmentItems.length, sections, }; } export function deriveEmailContentModel({ inlineResourceUrls, maxNestedMessageDepth = DEFAULT_MAX_NESTED_MESSAGE_DEPTH, message, nestedMessageDepth = 0, selectedNode, }: { inlineResourceUrls: ReadonlyMap; maxNestedMessageDepth?: number; message: EmailViewerMessage; nestedMessageDepth?: number; selectedNode: MimePartNode; }): EmailContentModel { if (isMessageNode(selectedNode) && selectedNode.children.length > 0) { if (nestedMessageDepth >= maxNestedMessageDepth) { return createEmptyContent({ message: "This nested message is too deeply nested to preview.", node: selectedNode, reason: "nested-depth-exceeded", }); } return { kind: "nested-message", maxNestedMessageDepth, node: selectedNode, message: deriveNestedEmailMessage(message, selectedNode), nestedMessageDepth: nestedMessageDepth + 1, }; } if (selectedNode.facts.preview.kind === "security-envelope") { return createEmptyContent({ message: `${selectedNode.facts.preview.label} cannot be previewed in this viewer.`, node: selectedNode, reason: "security-envelope", }); } const fileNode = selectDefaultPreviewNode(selectedNode, { stopAtNestedMessages: false, }); if (!fileNode) { return createEmptyContent({ message: DEFAULT_EMPTY_CONTENT_MESSAGE, node: selectedNode, reason: selectedNode.facts.preview.kind === "unsupported" ? selectedNode.facts.preview.reason : "no-previewable-body", }); } if (fileNode.facts.preview.kind === "security-envelope") { return createEmptyContent({ message: `${fileNode.facts.preview.label} cannot be previewed in this viewer.`, node: fileNode, reason: "security-envelope", }); } if (!fileNode.part.source) { return createEmptyContent({ message: "This MIME part is missing a preview source.", node: fileNode, reason: "missing-source", }); } return { kind: "file", node: fileNode, file: { category: categoryForMimeNode(fileNode), source: resolveEmailPreviewSource(fileNode, inlineResourceUrls), }, }; } export function deriveEmailInlineResourceScope( rootNode: MimePartNode, selectedNode: MimePartNode, ): EmailInlineResourceScope { if (isMessageNode(selectedNode)) { return { root: selectedNode, resources: [], }; } const displayNode = selectDefaultPreviewNode(selectedNode, { stopAtNestedMessages: true, }); const root = displayNode ? getInlineResourceScope(rootNode, displayNode) : selectedNode; return { root, resources: collectInlineResourceParts(root), }; } export function collectInlineResourceParts( node: MimePartNode, ): readonly EmailInlineResource[] { const resources: EmailInlineResource[] = []; walkMimeTree(node, (current) => { if (!isInlineResourceNode(current) || !current.part.source) return; const keys = inlineResourceKeysForNode(current); if (keys.length > 0) resources.push({ node: current, keys }); }); return resources; } export function getInlineResourceScope( rootNode: MimePartNode, node: MimePartNode, ): MimePartNode { let current: MimePartNode | null = node; while (current) { if (isRelatedMultipart(current.facts.mimeType)) return current; current = getParentMimeNode(rootNode, current); } return node; } export function normalizeContentId(contentId: string | null | undefined) { const trimmed = contentId?.trim(); if (!trimmed) return null; return trimmed.replace(/^<|>$/g, "").toLowerCase(); } export function normalizeContentLocation( contentLocation: string | null | undefined, ) { const trimmed = contentLocation?.trim(); if (!trimmed) return null; return normalizeRelativeReference(trimmed); } export function inlineResourceKeyToString(key: EmailInlineResourceKey) { return `${key.kind}:${key.value}`; } export function replaceInlineResourceUrls( html: string, inlineUrls: ReadonlyMap, ) { return replaceContentLocationUrls( replaceCidUrls(html, inlineUrls), inlineUrls, ); } export function replaceCidUrls( html: string, inlineUrls: ReadonlyMap, ) { return html.replace( /\bcid:(?:<([^>"'\s)]+)>|([^"'\s>)]+))/gi, (match, bracketedContentId, plainContentId) => { const rawContentId = bracketedContentId ?? plainContentId; const cid = normalizeContentId(decodeCid(rawContentId)); if (!cid) return match; return ( inlineUrls.get( inlineResourceKeyToString({ kind: "content-id", value: cid }), ) ?? MISSING_EMAIL_INLINE_RESOURCE_URL ); }, ); } export function mimePartLabel(part: MimePart): string { const fileName = part.fileName?.trim(); if (fileName) return fileName; if (isMultipartMime(part.mimeType)) return multipartLabel(part.mimeType); if (isMessageMime(part.mimeType)) return "Message"; if (normalizedMimeType(part.mimeType) === "text/html") return "HTML body"; if (normalizedMimeType(part.mimeType) === "text/plain") return "Text body"; if (isSecurityEnvelopeMime(part.mimeType)) return securityEnvelopeLabel(part.mimeType); return part.mimeType || "MIME part"; } export function mimePartDescription(part: MimePart): string { const pieces = [ part.mimeType || null, part.disposition?.trim() || null, part.contentId ? `cid:${normalizeContentId(part.contentId)}` : null, contentLocationForPart(part) ? `location:${contentLocationForPart(part)}` : null, ].filter(Boolean); return pieces.join(" · "); } export function categoryForMimePart(part: MimePart): FileCategory | undefined { const mime = normalizedMimeType(part.mimeType); if (mime === "text/calendar" || mime === "application/ics") return "text"; if (mime === "message/delivery-status") return "text"; if (mime === "message/disposition-notification") return "text"; const fileName = part.fileName?.trim() || part.source?.fileName || mime; const sourceMimeType = part.source?.mimeType || part.mimeType || undefined; const category = detectCategory(fileName, sourceMimeType); return category === "unsupported" ? undefined : category; } export function categoryForMimeNode( node: MimePartNode, ): FileCategory | undefined { const policy = node.facts.preview; if (policy.kind === "preview" || policy.kind === "attachment") { return policy.category; } return categoryForMimePart(node.part); } export function messageIdentity(message: MimeMessage): string { return message.id ?? message.root.id; } export function pathsEqual(left: MimePartPath, right: MimePartPath) { if (left.length !== right.length) return false; return left.every((part, index) => part === right[index]); } export function isMultipartNode(node: MimePartNode) { return node.facts.kind === "multipart"; } export function isMessageNode(node: MimePartNode) { return node.facts.kind === "message"; } export function isRenderableNode(node: MimePartNode) { return node.facts.isRenderable; } export function isAttachmentNode(node: MimePartNode) { return node.facts.kind === "attachment"; } export function isInlineResourceNode(node: MimePartNode) { return node.facts.kind === "inline-resource"; } function buildMimeNode({ part, parentPath, depth, pathPart, }: { part: MimePart; parentPath: MimePartPath | null; depth: number; pathPart: string; }): MimePartNode { const path = [...(parentPath ?? []), pathPart]; const facts = deriveMimePartFacts(part); const childIds = new Map(); return { depth, facts, parentPath, part, path, children: (part.children ?? []).map((child) => { const childPathPart = uniqueChildPathPart(child.id, childIds); return buildMimeNode({ part: child, parentPath: path, depth: depth + 1, pathPart: childPathPart, }); }), }; } function deriveMimePartFacts(part: MimePart): MimePartFacts { const mimeType = normalizedMimeType(part.mimeType); const disposition = part.disposition?.toLowerCase().trim() ?? null; const contentId = normalizeContentId(part.contentId); const contentLocation = contentLocationForPart(part); const isRenderable = Boolean(part.source); const kind = deriveMimePartKind({ contentId, contentLocation, disposition, isRenderable, mimeType, part, }); return { contentId, contentLocation, disposition, isRenderable, kind, mimeType, preview: deriveMimePreviewPolicy({ isRenderable, kind, mimeType, part }), }; } function deriveMimePartKind({ contentId, contentLocation, disposition, isRenderable, mimeType, part, }: { contentId: string | null; contentLocation: string | null; disposition: string | null; isRenderable: boolean; mimeType: string; part: MimePart; }): MimePartKind { if (isMultipartMime(mimeType)) return "multipart"; if (isMessageMime(mimeType)) return "message"; if ( isRenderable && disposition !== "attachment" && !isBodyMime(mimeType) && Boolean(contentId || contentLocation) ) { return "inline-resource"; } if (disposition === "attachment") return "attachment"; if (isRenderable && isBodyMime(mimeType)) return "body"; if (isRenderable && part.fileName && disposition === "inline") { return "attachment"; } if (isRenderable && !isSecurityEnvelopeMime(mimeType)) return "attachment"; return "unsupported"; } function deriveMimePreviewPolicy({ isRenderable, kind, mimeType, part, }: { isRenderable: boolean; kind: MimePartKind; mimeType: string; part: MimePart; }): MimePreviewPolicy { if (isSecurityEnvelopeMime(mimeType)) { return { kind: "security-envelope", label: securityEnvelopeLabel(mimeType), }; } if (kind === "message") return { kind: "nested-message" }; if (kind === "attachment") { return { kind: "attachment", category: categoryForMimePart(part) }; } if (isRenderable && kind === "body") { return { kind: "preview", category: categoryForMimePart(part) }; } if (isDeliveryStatusMime(mimeType)) { return { kind: "unsupported", reason: "unsupported-part" }; } return { kind: "unsupported", reason: isRenderable ? "unsupported-part" : "missing-source", }; } function uniqueChildPathPart(id: string, siblingCounts: Map) { const base = normalizePathPart(id, siblingCounts.size); const count = siblingCounts.get(base) ?? 0; siblingCounts.set(base, count + 1); return count === 0 ? base : `${base}~${count + 1}`; } function normalizePathPart(id: string, fallbackIndex: number) { const trimmed = id.trim(); return trimmed || `part-${fallbackIndex + 1}`; } function selectMimeScopeBodyNode( root: MimePartNode, policy: EmailBodySelectionPolicy = DEFAULT_EMAIL_BODY_SELECTION_POLICY, ): MimePartNode | null { const candidates: MimePartNode[] = []; walkCurrentMessageNodes(root, (node) => { if (!isRenderableNode(node)) return; if (!policy.includeInlineBodyParts && isInlineResourceNode(node)) return; if (!policy.includeAttachments && isAttachmentNode(node)) return; if (isInlineResourceNode(node) || isMessageNode(node)) return; candidates.push(node); }); for (const mimeType of policy.preferredMimeTypes) { const match = candidates.find((node) => node.facts.mimeType === mimeType); if (match) return match; } return ( candidates[0] ?? selectDefaultPreviewNode(root, { stopAtNestedMessages: true }) ); } function selectDefaultPreviewNode( node: MimePartNode, { stopAtNestedMessages, }: { stopAtNestedMessages: boolean; }, ): MimePartNode | null { if (isMessageNode(node) && stopAtNestedMessages) return null; if (isPreviewLeafNode(node)) return node; if (!node.children.length) return null; if ( node.facts.mimeType === "multipart/alternative" || node.facts.mimeType === "multipart/related" ) { return ( findFirstRenderableOfMime(node, "text/html", { stopAtNestedMessages }) ?? findFirstRenderableOfMime(node, "text/plain", { stopAtNestedMessages, }) ?? findFirstRenderableChild(node, { stopAtNestedMessages }) ); } return findFirstRenderableChild(node, { stopAtNestedMessages }); } function findFirstRenderableOfMime( node: MimePartNode, mimeType: string, options: { stopAtNestedMessages: boolean }, ): MimePartNode | null { for (const child of node.children) { if (isMessageNode(child) && options.stopAtNestedMessages) continue; if ( child.facts.mimeType === mimeType && isRenderableNode(child) && !isInlineResourceNode(child) ) { return child; } const match = findFirstRenderableOfMime(child, mimeType, options); if (match) return match; } return null; } function findFirstRenderableChild( node: MimePartNode, options: { stopAtNestedMessages: boolean }, ): MimePartNode | null { for (const child of node.children) { const match = selectDefaultPreviewNode(child, options); if (match) return match; } return null; } function isPreviewLeafNode(node: MimePartNode) { if (!isRenderableNode(node) || isInlineResourceNode(node)) return false; return ( node.facts.preview.kind === "preview" || node.facts.preview.kind === "attachment" ); } function collectCurrentMessageNodes(root: MimePartNode) { const nodes: MimePartNode[] = []; walkCurrentMessageNodes(root, (node) => nodes.push(node)); return nodes; } function walkCurrentMessageNodes( root: MimePartNode, visit: (node: MimePartNode) => void, ) { function walk(node: MimePartNode) { visit(node); if (!pathsEqual(node.path, root.path) && isMessageNode(node)) return; for (const child of node.children) walk(child); } walk(root); } function walkMimeTree(node: MimePartNode, visit: (node: MimePartNode) => void) { visit(node); for (const child of node.children) walkMimeTree(child, visit); } function isEmailAttachmentSidebarNode( node: MimePartNode, bodyNode: MimePartNode | null, ) { if (node === bodyNode) return false; if (isMultipartNode(node) || isInlineResourceNode(node)) return false; if (isMessageNode(node) || isAttachmentNode(node)) return true; return isRenderableNode(node) && !isBodyMime(node.facts.mimeType); } function createSidebarItem({ inlineResourceUrls, kind, node, selectedPath, }: { inlineResourceUrls: ReadonlyMap; kind: "body" | "attachment"; node: MimePartNode; selectedPath: MimePartPath; }): EmailSidebarItem { const common = { id: node.path.join("/"), node, path: node.path, description: describeEmailSidebarNode(node), thumbnail: deriveEmailSidebarThumbnail(node, inlineResourceUrls), isSelected: pathsEqual(node.path, selectedPath), }; if (kind === "body") { return { ...common, kind, title: "Body", }; } return { ...common, kind, title: mimePartLabel(node.part), }; } function deriveEmailSidebarThumbnail( node: MimePartNode, inlineResourceUrls: ReadonlyMap, ): EmailSidebarThumbnailModel { const thumbnailNode = isMessageNode(node) ? selectMimeScopeBodyNode(node) : node; if (thumbnailNode?.part.source && !isInlineResourceNode(thumbnailNode)) { return { kind: "file", source: resolveEmailPreviewSource(thumbnailNode, inlineResourceUrls), aspectRatio: 1, }; } if (isMessageNode(node)) return { kind: "icon", icon: "mail" }; if (isMultipartNode(node)) return { kind: "icon", icon: "layers" }; if (isAttachmentNode(node)) return { kind: "icon", icon: "paperclip" }; return { kind: "icon", icon: "file" }; } function describeEmailSidebarNode(node: MimePartNode) { if (node.part.size != null) { return `${node.part.mimeType} · ${formatFileSize(node.part.size)}`; } if (isInlineResourceNode(node)) return `${node.part.mimeType} · inline`; if (isAttachmentNode(node)) return `${node.part.mimeType} · attachment`; return node.part.mimeType; } function deriveNestedEmailMessage( message: EmailViewerMessage, node: MimePartNode, ): EmailViewerMessage { return { id: `${messageIdentity(message)}:${node.path.join("/")}`, headers: node.part.headers, subject: headerValue(node.part.headers, "subject"), from: headerValue(node.part.headers, "from"), to: headerValue(node.part.headers, "to"), cc: headerValue(node.part.headers, "cc"), bcc: headerValue(node.part.headers, "bcc"), sentAt: headerValue(node.part.headers, "date"), root: node.part, }; } function resolveEmailPreviewSource( node: MimePartNode, inlineResourceUrls: ReadonlyMap, ): ViewerSource { const source = node.part.source; if (source?.kind === "text" && isHtmlMime(node.part)) { const text = replaceInlineResourceUrls(source.text, inlineResourceUrls); if (text === source.text) return source; return { ...source, identityKey: [ source.identityKey ?? node.path.join("/"), "email-inline", inlineResourceIdentity(inlineResourceUrls), ].join(":"), text, }; } return source!; } function createEmptyContent({ message, node, reason, }: { message: string; node: MimePartNode; reason: EmailContentEmptyReason; }): EmailContentModel { return { kind: "empty", message, node, reason, }; } function normalizeAddressList( value: string | readonly string[] | null | undefined, ): readonly EmailAddress[] { if (typeof value === "string") return parseAddressList(value); if (!value) return []; return value.flatMap((address) => parseAddressList(address)); } function parseAddressList(value: string): readonly EmailAddress[] { return value .split(/,(?=(?:[^"]*"[^"]*")*[^"]*$)/) .map((address) => parseEmailAddress(address)) .filter((address) => address.display.length > 0); } function parseEmailAddress(value: string): EmailAddress { const display = value.trim(); const match = display.match(/^(.*?)<([^>]+)>$/); if (!match) { return { name: null, address: display.includes("@") ? display : null, display, }; } const name = cleanAddressName(match[1]); const address = match[2]?.trim() || null; return { name, address, display, }; } function cleanAddressName(value: string | undefined) { const trimmed = value?.trim().replace(/^"|"$/g, "") ?? ""; return trimmed || null; } function formatSentAt(value: string | Date | null | undefined) { if (!value) return null; const date = value instanceof Date ? value : new Date(value); if (Number.isNaN(date.getTime())) return null; return new Intl.DateTimeFormat(undefined, { dateStyle: "medium", timeStyle: "short", }).format(date); } function headerValue( headers: readonly { name: string; value: string }[] | undefined, name: string, ) { return ( headers?.find((header) => header.name.toLowerCase() === name.toLowerCase()) ?.value ?? null ); } function contentLocationForPart(part: MimePart) { return normalizeContentLocation( part.contentLocation ?? headerValue(part.headers, "content-location"), ); } function inlineResourceKeysForNode( node: MimePartNode, ): readonly EmailInlineResourceKey[] { const keys: EmailInlineResourceKey[] = []; if (node.facts.contentId) { keys.push({ kind: "content-id", value: node.facts.contentId }); } if (node.facts.contentLocation) { keys.push({ kind: "content-location", value: node.facts.contentLocation }); } return keys; } function replaceContentLocationUrls( html: string, inlineUrls: ReadonlyMap, ) { return html.replace( /\b(src|href)=(["'])([^"']+)\2/gi, (match, attribute, quote, rawUrl) => { if (!isRelativeInlineReference(rawUrl)) return match; const normalized = normalizeRelativeReference(rawUrl); const url = inlineUrls.get( inlineResourceKeyToString({ kind: "content-location", value: normalized, }), ); return url ? `${attribute}=${quote}${url}${quote}` : match; }, ); } function isRelativeInlineReference(value: string) { const lower = value.trim().toLowerCase(); if (!lower) return false; if (lower.startsWith("#")) return false; if (lower.startsWith("/")) return false; if (lower.startsWith("cid:")) return false; if (lower.startsWith("data:")) return false; return !/^[a-z][a-z0-9+.-]*:/i.test(lower); } function normalizeRelativeReference(value: string) { return value .trim() .replace(/^\.\/+/, "") .replace(/\\/g, "/") .toLowerCase(); } function getParentMimeNode(rootNode: MimePartNode, node: MimePartNode) { return node.parentPath ? findMimeNodeByPath(rootNode, node.parentPath) : null; } function inlineResourceIdentity( inlineResourceUrls: ReadonlyMap, ) { return Array.from(inlineResourceUrls.entries()) .sort(([left], [right]) => left.localeCompare(right)) .map(([key, url]) => `${key}=${url}`) .join("|"); } function decodeCid(value: string) { try { return decodeURIComponent(value); } catch { return value; } } function isHtmlMime(part: MimePart) { return normalizedMimeType(part.mimeType) === "text/html"; } function isBodyMime(mimeType: string) { return ( mimeType === "text/html" || mimeType === "text/plain" || mimeType === "text/markdown" ); } function isMultipartMime(mimeType: string) { return normalizedMimeType(mimeType).startsWith("multipart/"); } function isRelatedMultipart(mimeType: string) { return normalizedMimeType(mimeType) === "multipart/related"; } function isMessageMime(mimeType: string) { const mime = normalizedMimeType(mimeType); return mime === "message/rfc822" || mime === "message/global"; } function isDeliveryStatusMime(mimeType: string) { const mime = normalizedMimeType(mimeType); return ( mime === "message/delivery-status" || mime === "message/disposition-notification" ); } function isSecurityEnvelopeMime(mimeType: string) { const mime = normalizedMimeType(mimeType); return ( mime === "application/pkcs7-mime" || mime === "application/pgp-encrypted" || mime === "multipart/encrypted" ); } function securityEnvelopeLabel(mimeType: string) { const mime = normalizedMimeType(mimeType); if (mime.includes("encrypted")) return "Encrypted message"; if (mime.includes("pkcs7")) return "Signed or encrypted message"; return "Security envelope"; } function normalizedMimeType(mimeType: string) { return mimeType.toLowerCase().split(";")[0].trim(); } function multipartLabel(mimeType: string) { const subtype = normalizedMimeType(mimeType).split("/")[1]; if (!subtype) return "Multipart"; return `Multipart ${subtype}`; } 54:T9dd,"use client"; import * as React from "react"; import type { ViewerSource } from "@/lib/viewer-source"; import { inlineResourceKeyToString, MISSING_EMAIL_INLINE_RESOURCE_URL, } from "./email-viewer-model"; import type { EmailInlineResourceScope } from "./email-viewer-types"; import { useKeyedMountEffect } from "@/hooks/use-keyed-mount-effect"; import { joinEffectKey } from "@/lib/effect-key"; export function useEmailInlineResourceUrls(scope: EmailInlineResourceScope) { const placeholderUrls = React.useMemo( () => createPlaceholderUrls(scope), [scope], ); const [materialized, setMaterialized] = React.useState<{ scope: EmailInlineResourceScope; urls: ReadonlyMap; }>(() => ({ scope, urls: placeholderUrls, })); useKeyedMountEffect(joinEffectKey([scope]), () => { const nextUrls = new Map(); const objectUrls: string[] = []; for (const resource of scope.resources) { const source = resource.node.part.source; if (!source) continue; const url = sourceToInlineUrl(source, objectUrls); if (!url) continue; for (const key of resource.keys) { nextUrls.set(inlineResourceKeyToString(key), url); } } setMaterialized({ scope, urls: nextUrls, }); return () => { for (const url of objectUrls) URL.revokeObjectURL(url); }; }); return materialized.scope === scope ? materialized.urls : placeholderUrls; } function createPlaceholderUrls(scope: EmailInlineResourceScope) { const urls = new Map(); for (const resource of scope.resources) { for (const key of resource.keys) { urls.set( inlineResourceKeyToString(key), MISSING_EMAIL_INLINE_RESOURCE_URL, ); } } return urls; } function sourceToInlineUrl(source: ViewerSource, objectUrls: string[]) { if (source.kind === "url") return source.url; if (source.kind === "blob") { const url = URL.createObjectURL(source.blob); objectUrls.push(url); return url; } return textSourceToDataUrl(source.text, source.mimeType); } function textSourceToDataUrl(text: string, mimeType: string | undefined) { const bytes = new TextEncoder().encode(text); const chunkSize = 0x8000; let binary = ""; for (let index = 0; index < bytes.length; index += chunkSize) { binary += String.fromCharCode(...bytes.subarray(index, index + chunkSize)); } return `data:${mimeType ?? "text/plain;charset=utf-8"};base64,${btoa(binary)}`; } 55:T1437,import type { ReactNode } from "react"; import type { FileCategory, ViewerSource } from "@/lib/viewer-source"; export type MimePartDisposition = "inline" | "attachment" | string; export type MimeHeader = { name: string; value: string; }; export type MimePart = { id: string; mimeType: string; headers?: readonly MimeHeader[]; fileName?: string | null; disposition?: MimePartDisposition | null; contentId?: string | null; contentLocation?: string | null; size?: number | null; source?: ViewerSource; children?: readonly MimePart[]; }; export type MimeMessage = { id?: string; headers?: readonly MimeHeader[]; subject?: string | null; from?: string | readonly string[] | null; to?: string | readonly string[] | null; cc?: string | readonly string[] | null; bcc?: string | readonly string[] | null; sentAt?: string | Date | null; root: MimePart; }; export type MimePartPath = readonly string[]; export type MimePartKind = | "multipart" | "message" | "body" | "attachment" | "inline-resource" | "unsupported"; export type MimePreviewPolicy = | { kind: "preview"; category?: FileCategory } | { kind: "nested-message" } | { kind: "attachment"; category?: FileCategory } | { kind: "security-envelope"; label: string } | { kind: "unsupported"; reason: EmailContentEmptyReason }; export type MimePartFacts = { kind: MimePartKind; mimeType: string; disposition: string | null; contentId: string | null; contentLocation: string | null; isRenderable: boolean; preview: MimePreviewPolicy; }; export type MimePartNode = { part: MimePart; path: MimePartPath; parentPath: MimePartPath | null; depth: number; children: readonly MimePartNode[]; facts: MimePartFacts; }; export type EmailViewerMessage = MimeMessage; export type MimeMessageScope = { message: EmailViewerMessage; root: MimePartNode; path: MimePartPath; descendants: readonly MimePartNode[]; }; export type EmailAddress = { name: string | null; address: string | null; display: string; }; export type EmailHeaderModel = { subject: string; from: readonly EmailAddress[]; to: readonly EmailAddress[]; cc: readonly EmailAddress[]; bcc: readonly EmailAddress[]; sentAt: string | null; }; export type EmailSidebarThumbnailModel = | { kind: "file"; source: ViewerSource; aspectRatio: number } | { kind: "icon"; icon: "file" | "layers" | "mail" | "paperclip" }; export type EmailSidebarItemBase = { id: string; node: MimePartNode; path: MimePartPath; description: string; thumbnail: EmailSidebarThumbnailModel; isSelected: boolean; }; export type EmailBodySidebarItem = EmailSidebarItemBase & { kind: "body"; title: "Body"; }; export type EmailAttachmentSidebarItem = EmailSidebarItemBase & { kind: "attachment"; title: string; }; export type EmailSidebarItem = | EmailBodySidebarItem | EmailAttachmentSidebarItem; export type EmailSidebarSection = { id: "body" | "attachments"; title: string; items: readonly EmailSidebarItem[]; emptyLabel?: string; }; export type EmailSidebarModel = { bodyCount: number; attachmentCount: number; sections: readonly EmailSidebarSection[]; }; export type EmailFilePayload = { source: ViewerSource; category?: FileCategory; }; export type EmailContentFile = { kind: "file"; node: MimePartNode; file: EmailFilePayload; }; export type EmailContentNestedMessage = { kind: "nested-message"; node: MimePartNode; message: EmailViewerMessage; maxNestedMessageDepth: number; nestedMessageDepth: number; }; export type EmailContentEmptyReason = | "no-previewable-body" | "unsupported-part" | "missing-source" | "nested-depth-exceeded" | "security-envelope"; export type EmailContentEmpty = { kind: "empty"; reason: EmailContentEmptyReason; node: MimePartNode; message: string; }; export type EmailContentModel = | EmailContentFile | EmailContentNestedMessage | EmailContentEmpty; export type EmailInlineResourceKey = | { kind: "content-id"; value: string } | { kind: "content-location"; value: string }; export type EmailInlineResource = { node: MimePartNode; keys: readonly EmailInlineResourceKey[]; }; export type EmailInlineResourceScope = { root: MimePartNode; resources: readonly EmailInlineResource[]; }; export type EmailBodySelectionPolicy = { preferredMimeTypes: readonly string[]; includeInlineBodyParts: boolean; includeAttachments: boolean; }; export type EmailViewerModel = { message: EmailViewerMessage; rootNode: MimePartNode; scope: MimeMessageScope; selectedPath: MimePartPath; selectedNode: MimePartNode; header: EmailHeaderModel; sidebar: EmailSidebarModel; content: EmailContentModel; }; export type EmailViewerProps = { message: EmailViewerMessage; selectedPath?: MimePartPath | null; defaultSelectedPath?: MimePartPath; onSelectedPathChange?: (path: MimePartPath, node: MimePartNode) => void; maxNestedMessageDepth?: number; mode?: "auto" | "inline" | "overlay"; className?: string; }; export type EmailViewerProviderProps = Omit< EmailViewerProps, "className" | "mode" > & { children: ReactNode; }; 56:T1549,"use client"; import * as React from "react"; import { cn } from "@/lib/utils"; import { viewerContentRenderKey, type ViewerResource, } from "@/lib/viewer-resource"; import { useKeyedMountEffect } from "@/hooks/use-keyed-mount-effect"; import { joinEffectKey } from "@/lib/effect-key"; import { EmailViewer } from "./email-viewer"; import { parseEmlMessage } from "./email-viewer-eml"; import { ViewerFallback } from "./file-viewer-fallback"; import { loadTextResource } from "./file-viewer-text-resource"; import { isAbortError } from "./viewer-abortable-request"; import { useViewerControlsRegistration, type ViewerControlsState, } from "./viewer-controls"; export type EmailResourceContentProps = { resource: ViewerResource; className?: string; bare?: boolean; controls?: boolean; download?: boolean; descriptorSignal?: AbortSignal; }; type EmailLoadState = | { status: "loading"; key: unknown } | { status: "loaded"; key: unknown; emlText: string } | { status: "error"; key: unknown; error: unknown }; export function EmailResourceContent({ resource, className, bare, controls = true, download = true, descriptorSignal, }: EmailResourceContentProps) { if (resource.content.payload.kind === "text") { return ( ); } return ( ); } function EmailResourceLoader({ resource, className, bare, controls, download, descriptorSignal, }: { resource: ViewerResource; className?: string; bare?: boolean; controls: boolean; download: boolean; descriptorSignal?: AbortSignal; }) { const content = resource.content; const contentKey = content.key; const [state, setState] = React.useState({ status: "loading", key: contentKey, }); useKeyedMountEffect( joinEffectKey([content, contentKey, descriptorSignal, resource.fileName]), () => { let active = true; const controller = new AbortController(); const abortLocal = () => controller.abort(); setState({ status: "loading", key: contentKey }); if (descriptorSignal?.aborted) { abortLocal(); } else { descriptorSignal?.addEventListener("abort", abortLocal, { once: true, }); } loadTextResource({ content, fileName: resource.fileName, signal: controller.signal, }).then( (emlText) => { if (active && !controller.signal.aborted) { setState({ status: "loaded", key: contentKey, emlText }); } }, (error: unknown) => { if (!active || isAbortError(error)) return; setState({ status: "error", key: contentKey, error }); }, ); return () => { active = false; descriptorSignal?.removeEventListener("abort", abortLocal); abortLocal(); }; }, ); if (state.key !== contentKey || state.status === "loading") { return ( ); } if (state.status === "error") { throw state.error; } return ( ); } function EmailResourceFrame({ resource, emlText, className, bare, download, }: { resource: ViewerResource; emlText: string; className?: string; bare?: boolean; controls: boolean; download: boolean; }) { const message = React.useMemo( () => parseEmlMessage(emlText, { identityKey: resource.content.key }), [emlText, resource.content.key], ); useEmailResourceControlsRegistration({ download, downloadAction: resource.originalDownload, }); // The email viewer supplies its own domain chrome (message header, parts // sidebar); it tracks the live layout like the csv/html renderers, so it // registers no motion resolver — the kernel's identity default is correct. return (

); } function useEmailResourceControlsRegistration({ download, downloadAction, }: { download: boolean; downloadAction: ViewerResource["originalDownload"]; }) { const onControlsChange = useViewerControlsRegistration(); const controlsState = React.useMemo( () => ({ downloads: download && downloadAction ? [downloadAction] : [], }), [download, downloadAction], ); useKeyedMountEffect( joinEffectKey(["email-controls", onControlsChange, controlsState]), () => { if (!onControlsChange) return; onControlsChange(controlsState); return () => onControlsChange(null); }, ); } 57:T3921,import { blobSource } from "@/lib/viewer-resource"; import { textPayloadKey, type ViewerSource } from "@/lib/viewer-source"; import type { EmailViewerMessage, MimeHeader, MimePart, } from "./email-viewer-types"; /** * Lenient RFC 822/2045 `.eml` parser producing the `EmailViewerMessage` shape * consumed by `EmailViewer`. It never throws on malformed input: unparseable * structure degrades to a single text part so the viewer still renders. */ export type ParseEmlOptions = { /** * Stable identity prefix for derived part sources. Defaults to a content * hash of the message text so re-parsing the same bytes interns to the * same viewer resources. */ identityKey?: string; }; const MAX_MIME_DEPTH = 24; const LINE_ENDING_PATTERN = /\r\n?/g; export function parseEmlMessage( emlText: string, options: ParseEmlOptions = {}, ): EmailViewerMessage { const text = emlText.replace(LINE_ENDING_PATTERN, "\n"); const identityBase = options.identityKey ?? `eml-${textPayloadKey(text)}`; const { headers, body } = splitEntity(text); const root = parseEntityPart({ headers, body, id: "root", identityBase, depth: 0, }); return { id: identityBase, headers, subject: decodedHeader(headers, "subject"), from: decodedHeader(headers, "from"), to: decodedHeader(headers, "to"), cc: decodedHeader(headers, "cc"), bcc: decodedHeader(headers, "bcc"), sentAt: headerValue(headers, "date"), root, }; } type MimeEntity = { headers: readonly MimeHeader[]; body: string; }; type ParseEntityInput = MimeEntity & { id: string; identityBase: string; depth: number; }; function parseEntityPart({ headers, body, id, identityBase, depth, }: ParseEntityInput): MimePart { const contentType = parseParameterizedHeader( headerValue(headers, "content-type") ?? "text/plain", ); const mimeType = contentType.value || "text/plain"; const disposition = parseParameterizedHeader( headerValue(headers, "content-disposition") ?? "", ); const fileName = readNameParameter(disposition.params, "filename") ?? readNameParameter(contentType.params, "name"); const base: MimePart = { id, mimeType, headers, fileName: fileName ?? null, disposition: disposition.value || null, contentId: headerValue(headers, "content-id"), contentLocation: headerValue(headers, "content-location"), }; const encoding = (headerValue(headers, "content-transfer-encoding") ?? "") .trim() .toLowerCase(); if (depth < MAX_MIME_DEPTH) { const boundary = contentType.params["boundary"]; if (mimeType.startsWith("multipart/") && boundary) { const sections = splitMultipartSections(body, boundary); if (sections.length > 0) { return { ...base, children: sections.map((section, index) => { const entity = splitEntity(section); return parseEntityPart({ ...entity, id: `${id}.${index + 1}`, identityBase, depth: depth + 1, }); }), }; } } if (mimeType === "message/rfc822" || mimeType === "message/global") { const nestedText = decodeBodyToText(body, encoding, "utf-8"); const nested = splitEntity(nestedText); const nestedRoot = parseEntityPart({ ...nested, id: `${id}.m`, identityBase, depth: depth + 1, }); return { ...base, // Nested message headers (Subject/From/…) ride on the rfc822 part so // the email model can derive the nested viewer's message from it. headers: [...headers, ...nested.headers], children: [nestedRoot], }; } } return { ...base, ...leafSource({ body, encoding, fileName, id, identityBase, mimeType, charset: contentType.params["charset"], }), }; } function leafSource({ body, charset, encoding, fileName, id, identityBase, mimeType, }: { body: string; charset: string | undefined; encoding: string; fileName: string | null | undefined; id: string; identityBase: string; mimeType: string; }): Pick { const identityKey = `${identityBase}:${id}`; const resolvedFileName = fileName ?? defaultLeafFileName(mimeType); if (isTextualMime(mimeType)) { const text = decodeBodyToText(body, encoding, charset); const source: ViewerSource = { kind: "text", text, fileName: resolvedFileName, mimeType, identityKey, }; return { source, size: text.length }; } const bytes = decodeBodyToBytes(body, encoding); return { source: blobSource(bytes, { identityKey, fileName: resolvedFileName, mimeType, }), size: bytes.byteLength, }; } function isTextualMime(mimeType: string) { return ( mimeType.startsWith("text/") || mimeType === "application/json" || mimeType === "application/xml" || mimeType === "image/svg+xml" || mimeType.startsWith("message/") ); } function defaultLeafFileName(mimeType: string) { if (mimeType === "text/html") return "message.html"; if (mimeType === "text/plain") return "message.txt"; return undefined; } // --- entity + header parsing --------------------------------------------- function splitEntity(text: string): MimeEntity { const trimmed = text.startsWith("\n") ? text.slice(1) : text; if (trimmed !== text) { // Entity starts with a blank line: empty header block, all body. return { headers: [], body: trimmed }; } const separator = text.indexOf("\n\n"); if (separator === -1) { // No blank line: treat a colon-bearing block as headers-only, otherwise // as a bare body with no headers. if (looksLikeHeaderBlock(text)) { return { headers: parseHeaderBlock(text), body: "" }; } return { headers: [], body: text }; } const headerBlock = text.slice(0, separator); if (!looksLikeHeaderBlock(headerBlock)) { return { headers: [], body: text }; } return { headers: parseHeaderBlock(headerBlock), body: text.slice(separator + 2), }; } function looksLikeHeaderBlock(block: string) { const firstLine = block.slice(0, block.indexOf("\n") + 1 || undefined); return /^[!-9;-~]+:/.test(firstLine); } function parseHeaderBlock(block: string): MimeHeader[] { const unfolded: string[] = []; for (const line of block.split("\n")) { if ((line.startsWith(" ") || line.startsWith("\t")) && unfolded.length) { unfolded[unfolded.length - 1] += ` ${line.trim()}`; continue; } unfolded.push(line); } const headers: MimeHeader[] = []; for (const line of unfolded) { const colon = line.indexOf(":"); if (colon <= 0) continue; headers.push({ name: line.slice(0, colon).trim(), value: line.slice(colon + 1).trim(), }); } return headers; } function headerValue( headers: readonly MimeHeader[], name: string, ): string | null { const lower = name.toLowerCase(); for (const header of headers) { if (header.name.toLowerCase() === lower) return header.value; } return null; } function decodedHeader(headers: readonly MimeHeader[], name: string) { const value = headerValue(headers, name); return value == null ? null : decodeEncodedWords(value); } type ParameterizedHeader = { value: string; params: Record; }; function parseParameterizedHeader(raw: string): ParameterizedHeader { const [first, ...rest] = splitOutsideQuotes(raw, ";"); const params: Record = {}; const continuations = new Map>(); for (const segment of rest) { const equals = segment.indexOf("="); if (equals === -1) continue; const rawName = segment.slice(0, equals).trim().toLowerCase(); let value = segment.slice(equals + 1).trim(); if (value.startsWith('"') && value.endsWith('"') && value.length >= 2) { value = value.slice(1, -1).replace(/\\(.)/g, "$1"); } const continuation = rawName.match(/^(.*)\*(\d+)(\*)?$/); if (continuation) { const [, baseName, indexText, extended] = continuation; const index = Number(indexText); let sections = continuations.get(baseName); if (!sections) { sections = new Map(); continuations.set(baseName, sections); } sections.set( index, extended && index === 0 ? decodeRfc2231Value(value) : decodePercents(value, extended != null), ); continue; } if (rawName.endsWith("*")) { params[rawName.slice(0, -1)] = decodeRfc2231Value(value); continue; } params[rawName] = value; } for (const [name, sections] of continuations) { const ordered = [...sections.entries()].sort((a, b) => a[0] - b[0]); params[name] = ordered.map(([, section]) => section).join(""); } return { value: (first ?? "").trim().toLowerCase(), params }; } function decodeRfc2231Value(value: string) { const match = value.match(/^([^']*)'[^']*'([\s\S]*)$/); if (!match) return decodePercents(value, true); const [, charset, encoded] = match; return decodePercentsWithCharset(encoded, charset || "utf-8"); } function decodePercents(value: string, extended: boolean) { return extended ? decodePercentsWithCharset(value, "utf-8") : value; } function decodePercentsWithCharset(value: string, charset: string) { const bytes: number[] = []; const encoder = new TextEncoder(); for (let index = 0; index < value.length; index += 1) { const char = value[index]; if (char === "%" && /^[0-9A-Fa-f]{2}$/.test(value.slice(index + 1, index + 3))) { bytes.push(Number.parseInt(value.slice(index + 1, index + 3), 16)); index += 2; continue; } bytes.push(...encoder.encode(char)); } return decodeBytes(new Uint8Array(bytes), charset); } function splitOutsideQuotes(value: string, separator: string) { const segments: string[] = []; let current = ""; let inQuotes = false; for (let index = 0; index < value.length; index += 1) { const char = value[index]; if (char === '"' && value[index - 1] !== "\\") inQuotes = !inQuotes; if (char === separator && !inQuotes) { segments.push(current); current = ""; continue; } current += char; } segments.push(current); return segments; } function readNameParameter( params: Record, name: string, ): string | null { const value = params[name]; if (!value) return null; return decodeEncodedWords(value); } // --- RFC 2047 encoded words ----------------------------------------------- const ENCODED_WORD_PATTERN = /=\?([^?\s]+)\?([bq])\?([^?\s]*)\?=/gi; export function decodeEncodedWords(value: string): string { // Whitespace between two adjacent encoded words is not significant. const joined = value.replace(/(\?=)\s+(=\?)/g, "$1$2"); return joined.replace( ENCODED_WORD_PATTERN, (whole, charset: string, encoding: string, data: string) => { try { const bytes = encoding.toLowerCase() === "b" ? base64ToBytes(data) : qEncodedToBytes(data); return decodeBytes(bytes, charset); } catch { return whole; } }, ); } function qEncodedToBytes(data: string) { const bytes: number[] = []; for (let index = 0; index < data.length; index += 1) { const char = data[index]; if (char === "_") { bytes.push(0x20); continue; } if ( char === "=" && /^[0-9A-Fa-f]{2}$/.test(data.slice(index + 1, index + 3)) ) { bytes.push(Number.parseInt(data.slice(index + 1, index + 3), 16)); index += 2; continue; } bytes.push(char.charCodeAt(0) & 0xff); } return new Uint8Array(bytes); } // --- transfer decoding ------------------------------------------------------ function decodeBodyToText( body: string, encoding: string, charset: string | undefined, ) { if (encoding === "base64") { try { return decodeBytes(base64ToBytes(body), charset ?? "utf-8"); } catch { return body; } } if (encoding === "quoted-printable") { return decodeBytes(quotedPrintableToBytes(body), charset ?? "utf-8"); } // 7bit / 8bit / binary / unknown: the surrounding message was already // decoded to a string, so the payload is used as-is. return body; } function decodeBodyToBytes(body: string, encoding: string): Uint8Array { if (encoding === "base64") { try { return base64ToBytes(body); } catch { return new TextEncoder().encode(body); } } if (encoding === "quoted-printable") { return quotedPrintableToBytes(body); } return new TextEncoder().encode(body); } function base64ToBytes(data: string) { const clean = data.replace(/[^A-Za-z0-9+/=]/g, ""); const binary = atob(clean); const bytes = new Uint8Array(binary.length); for (let index = 0; index < binary.length; index += 1) { bytes[index] = binary.charCodeAt(index); } return bytes; } function quotedPrintableToBytes(body: string) { // Soft line breaks join the surrounding lines. const text = body.replace(/=\n/g, ""); const bytes: number[] = []; const encoder = new TextEncoder(); for (let index = 0; index < text.length; index += 1) { const char = text[index]; if ( char === "=" && /^[0-9A-Fa-f]{2}$/.test(text.slice(index + 1, index + 3)) ) { bytes.push(Number.parseInt(text.slice(index + 1, index + 3), 16)); index += 2; continue; } bytes.push(...encoder.encode(char)); } return new Uint8Array(bytes); } function decodeBytes(bytes: Uint8Array, charset: string | undefined) { try { return new TextDecoder(charset || "utf-8").decode(bytes); } catch { return new TextDecoder("utf-8").decode(bytes); } } // --- multipart -------------------------------------------------------------- function splitMultipartSections(body: string, boundary: string): string[] { const delimiter = `--${boundary}`; const closingDelimiter = `${delimiter}--`; const sections: string[][] = []; let current: string[] | null = null; for (const line of body.split("\n")) { const marker = line.trimEnd(); if (marker === closingDelimiter) { if (current) sections.push(current); current = null; break; } if (marker === delimiter) { if (current) sections.push(current); current = []; continue; } current?.push(line); } if (current) sections.push(current); return sections.map((lines) => lines.join("\n")); } 4f:["$","div",null,{"className":"mt-3 flex min-h-0 min-w-0 flex-1 flex-col gap-3","children":[["$","div",null,{"className":"flex shrink-0 items-start gap-3","children":[["$","div",null,{"className":"flex max-h-28 min-w-0 flex-1 flex-wrap items-center gap-2 overflow-y-auto","children":[["$","ul",null,{"className":"flex min-w-0 flex-wrap gap-2","aria-label":"Package dependencies","children":[["$","li","lucide-react",{"className":"min-w-0 max-w-full","children":["$","a",null,{"href":"https://www.npmjs.com/package/lucide-react","target":"_blank","rel":"noopener noreferrer","className":"flex max-w-full min-w-0 items-center gap-1.5 rounded-md border px-2 py-1.5 text-xs","children":[["$","svg",null,{"viewBox":"0 0 24 24","className":"size-3 shrink-0","children":["$","path",null,{"d":"M1.763 0C.786 0 0 .786 0 1.763v20.474C0 23.214.786 24 1.763 24h20.474c.977 0 1.763-.786 1.763-1.763V1.763C24 .786 23.214 0 22.237 0zM5.13 5.323l13.837.019-.009 13.836h-3.464l.01-10.382h-3.456L12.04 19.17H5.113z","fill":"currentColor"}]}],["$","span",null,{"className":"min-w-0 break-all text-xs font-medium","children":"lucide-react"}]]}]}]]}],["$","$L50",null,{"namespace":"@retab","registryDependencies":["@retab/utils","@retab/file-size-format","@retab/file-thumbnail","@retab/file-viewer","@retab/viewer-controls"]}]]}],null]}],["$","$L51",null,{"files":[{"path":"registry/new-york-v4/ui/email-viewer.tsx","content":"$52","type":"registry:ui","target":"@ui/email-viewer.tsx"},{"path":"registry/new-york-v4/ui/viewer.tsx","content":"\"use client\";\n\nexport { ViewerBody } from \"./viewer-body\";\nexport type { ViewerSidebarTriggerProps } from \"./viewer-chrome\";\nexport {\n ViewerFrame,\n ViewerHeader,\n ViewerSidebarTrigger,\n} from \"./viewer-chrome\";\nexport {\n ViewerRoot,\n useOptionalViewerSidebar,\n useViewerSidebar,\n} from \"./viewer-root\";\nexport { ViewerSidebar } from \"./viewer-sidebar\";\nexport { ViewerSurface, ViewerViewport } from \"./viewer-surface\";\nexport type {\n ViewerBodyProps,\n ViewerDataAttributes,\n ViewerFrameProps,\n ViewerHeaderProps,\n ViewerRootProps,\n ViewerSidebarCollapsible,\n ViewerSidebarStateValue,\n ViewerSidebarMode,\n ViewerSidebarProps,\n ViewerSidebarRequestedMode,\n ViewerSidebarSide,\n ViewerSidebarSlotNames,\n ViewerSidebarState,\n ViewerStateAttributeNamespace,\n ViewerStateAttributeSlot,\n ViewerStateAttributeValues,\n ViewerSurfaceProps,\n ViewerViewportProps,\n} from \"./viewer-types\";\n","type":"registry:ui","target":"@ui/viewer.tsx"},{"path":"registry/new-york-v4/ui/email-viewer-model.ts","content":"$53","type":"registry:ui","target":"@ui/email-viewer-model.ts"},{"path":"registry/new-york-v4/ui/email-viewer-inline-resources.ts","content":"$54","type":"registry:ui","target":"@ui/email-viewer-inline-resources.ts"},{"path":"registry/new-york-v4/ui/email-viewer-types.ts","content":"$55","type":"registry:ui","target":"@ui/email-viewer-types.ts"},{"path":"registry/new-york-v4/ui/email-viewer-content.tsx","content":"$56","type":"registry:ui","target":"@ui/email-viewer-content.tsx"},{"path":"registry/new-york-v4/ui/email-viewer-eml.ts","content":"$57","type":"registry:ui","target":"@ui/email-viewer-eml.ts"}],"className":"h-[70svh] min-h-80"}]]}]