207 lines
7.7 KiB
TypeScript
207 lines
7.7 KiB
TypeScript
import type { Element } from "hast";
|
|
import { type ComponentProps, memo, type ReactNode, Suspense } from "react";
|
|
import type { Components } from "react-markdown";
|
|
import ReactMarkdown from "react-markdown";
|
|
import rehypeRaw from "rehype-raw";
|
|
import rehypeSanitize from "rehype-sanitize";
|
|
import remarkBreaks from "remark-breaks";
|
|
import remarkGfm from "remark-gfm";
|
|
import { isMentionElement, isTagElement, isTaskListItemElement } from "@/types/markdown";
|
|
import { lazyWithReload } from "@/utils/lazy";
|
|
import { rehypeHeadingId } from "@/utils/rehype-plugins/rehype-heading-id";
|
|
import { remarkDisableSetext } from "@/utils/remark-plugins/remark-disable-setext";
|
|
import { remarkMention } from "@/utils/remark-plugins/remark-mention";
|
|
import { remarkPreserveType } from "@/utils/remark-plugins/remark-preserve-type";
|
|
import { remarkSplitMixedTaskLists } from "@/utils/remark-plugins/remark-split-mixed-task-lists";
|
|
import { remarkTag } from "@/utils/remark-plugins/remark-tag";
|
|
import { CodeBlock } from "./CodeBlock";
|
|
import { SANITIZE_SCHEMA } from "./constants";
|
|
import { MarkdownRenderContext, rootMarkdownRenderContext } from "./MarkdownRenderContext";
|
|
import { Mention } from "./Mention";
|
|
import { AnchorLink, Blockquote, Heading, HorizontalRule, Image, InlineCode, Link, List, ListItem, Paragraph } from "./markdown";
|
|
import { hasMathSyntax } from "./math";
|
|
import { Table, TableBody, TableCell, TableHead, TableHeaderCell, TableRow } from "./Table";
|
|
import { Tag } from "./Tag";
|
|
import { TaskListItem } from "./TaskListItem";
|
|
import { TrustedIframe } from "./TrustedIframe";
|
|
|
|
export interface MemoMarkdownRendererProps {
|
|
content: string;
|
|
resolvedMentionUsernames: Set<string>;
|
|
/** Resource name of the memo (e.g. `memos/abc123`), used to target footnote links at the detail page. */
|
|
memoName?: string;
|
|
/** Whether the memo is rendered as a collapsed feed card. */
|
|
compact?: boolean;
|
|
}
|
|
|
|
type RemarkPlugins = NonNullable<ComponentProps<typeof ReactMarkdown>["remarkPlugins"]>;
|
|
type RehypePlugins = NonNullable<ComponentProps<typeof ReactMarkdown>["rehypePlugins"]>;
|
|
|
|
interface MemoMarkdownRendererCoreProps extends MemoMarkdownRendererProps {
|
|
/** Math plugins injected by MathMarkdownRenderer; the remark ones must run before remarkGfm. */
|
|
mathRemarkPlugins?: RemarkPlugins;
|
|
mathRehypePlugins?: RehypePlugins;
|
|
}
|
|
|
|
const MathMarkdownRenderer = lazyWithReload(() => import("./MathMarkdownRenderer"));
|
|
|
|
function getMentionUsername(node: Element, children?: ReactNode): string {
|
|
const dataMention = node.properties?.["data-mention"];
|
|
if (typeof dataMention === "string" && dataMention !== "") {
|
|
return dataMention;
|
|
}
|
|
|
|
const camelDataMention = (node.properties as Record<string, unknown> | undefined)?.dataMention;
|
|
if (typeof camelDataMention === "string" && camelDataMention !== "") {
|
|
return camelDataMention;
|
|
}
|
|
|
|
const text = Array.isArray(children) ? children.join("") : children;
|
|
if (typeof text === "string" && text.startsWith("@")) {
|
|
return text.slice(1).toLowerCase();
|
|
}
|
|
|
|
return "";
|
|
}
|
|
|
|
export const MemoMarkdownRendererCore = ({
|
|
content,
|
|
resolvedMentionUsernames,
|
|
memoName,
|
|
compact,
|
|
mathRemarkPlugins = [],
|
|
mathRehypePlugins = [],
|
|
}: MemoMarkdownRendererCoreProps) => {
|
|
const markdownComponents: Components = {
|
|
input: ({ node, ...inputProps }) => {
|
|
if (node && isTaskListItemElement(node)) {
|
|
return <TaskListItem {...inputProps} node={node} />;
|
|
}
|
|
return <input {...inputProps} />;
|
|
},
|
|
span: ({ node, ...spanProps }) => {
|
|
if (node && isMentionElement(node)) {
|
|
const username = getMentionUsername(node, spanProps.children);
|
|
return <Mention {...spanProps} node={node} data-mention={username} resolved={resolvedMentionUsernames.has(username)} />;
|
|
}
|
|
if (node && isTagElement(node)) {
|
|
return <Tag {...spanProps} node={node} />;
|
|
}
|
|
return <span {...spanProps} />;
|
|
},
|
|
h1: ({ children, ...props }) => (
|
|
<Heading level={1} {...props}>
|
|
{children}
|
|
</Heading>
|
|
),
|
|
h2: ({ children, ...props }) => (
|
|
<Heading level={2} {...props}>
|
|
{children}
|
|
</Heading>
|
|
),
|
|
h3: ({ children, ...props }) => (
|
|
<Heading level={3} {...props}>
|
|
{children}
|
|
</Heading>
|
|
),
|
|
h4: ({ children, ...props }) => (
|
|
<Heading level={4} {...props}>
|
|
{children}
|
|
</Heading>
|
|
),
|
|
h5: ({ children, ...props }) => (
|
|
<Heading level={5} {...props}>
|
|
{children}
|
|
</Heading>
|
|
),
|
|
h6: ({ children, ...props }) => (
|
|
<Heading level={6} {...props}>
|
|
{children}
|
|
</Heading>
|
|
),
|
|
p: ({ children, ...props }) => <Paragraph {...props}>{children}</Paragraph>,
|
|
blockquote: ({ children, ...props }) => <Blockquote {...props}>{children}</Blockquote>,
|
|
hr: (props) => <HorizontalRule {...props} />,
|
|
ul: ({ children, ...props }) => <List {...props}>{children}</List>,
|
|
ol: ({ children, ...props }) => (
|
|
<List ordered {...props}>
|
|
{children}
|
|
</List>
|
|
),
|
|
li: ({ children, ...props }) => <ListItem {...props}>{children}</ListItem>,
|
|
a: ({ children, href, ...props }) => {
|
|
// In-page anchors (footnote refs/backrefs, heading links) navigate within the memo rather
|
|
// than opening a new tab; everything else is treated as an external link.
|
|
if (typeof href === "string" && href.startsWith("#")) {
|
|
return (
|
|
<AnchorLink href={href} memoName={memoName} compact={compact} {...props}>
|
|
{children}
|
|
</AnchorLink>
|
|
);
|
|
}
|
|
return (
|
|
<Link href={href} {...props}>
|
|
{children}
|
|
</Link>
|
|
);
|
|
},
|
|
code: ({ children, ...props }) => <InlineCode {...props}>{children}</InlineCode>,
|
|
iframe: TrustedIframe,
|
|
img: (props) => <Image {...props} />,
|
|
pre: CodeBlock,
|
|
table: ({ children, ...props }) => <Table {...props}>{children}</Table>,
|
|
thead: ({ children, ...props }) => <TableHead {...props}>{children}</TableHead>,
|
|
tbody: ({ children, ...props }) => <TableBody {...props}>{children}</TableBody>,
|
|
tr: ({ children, ...props }) => <TableRow {...props}>{children}</TableRow>,
|
|
th: ({ children, ...props }) => <TableHeaderCell {...props}>{children}</TableHeaderCell>,
|
|
td: ({ children, ...props }) => <TableCell {...props}>{children}</TableCell>,
|
|
};
|
|
|
|
return (
|
|
<MarkdownRenderContext.Provider value={rootMarkdownRenderContext}>
|
|
<ReactMarkdown
|
|
remarkPlugins={[
|
|
remarkDisableSetext,
|
|
...mathRemarkPlugins,
|
|
remarkGfm,
|
|
remarkSplitMixedTaskLists,
|
|
remarkTag,
|
|
remarkMention,
|
|
remarkBreaks,
|
|
remarkPreserveType,
|
|
]}
|
|
rehypePlugins={[rehypeRaw, [rehypeSanitize, SANITIZE_SCHEMA], rehypeHeadingId, ...mathRehypePlugins]}
|
|
components={markdownComponents}
|
|
>
|
|
{content}
|
|
</ReactMarkdown>
|
|
</MarkdownRenderContext.Provider>
|
|
);
|
|
};
|
|
|
|
const MemoMarkdownRendererComponent = (props: MemoMarkdownRendererProps) => {
|
|
if (!hasMathSyntax(props.content)) {
|
|
return <MemoMarkdownRendererCore {...props} />;
|
|
}
|
|
|
|
return (
|
|
<Suspense fallback={<MemoMarkdownRendererCore {...props} />}>
|
|
<MathMarkdownRenderer {...props} />
|
|
</Suspense>
|
|
);
|
|
};
|
|
|
|
const haveEqualResolvedMentions = (left: Set<string>, right: Set<string>) => {
|
|
if (left === right) return true;
|
|
if (left.size !== right.size) return false;
|
|
return Array.from(left).every((username) => right.has(username));
|
|
};
|
|
|
|
export const MemoMarkdownRenderer = memo(
|
|
MemoMarkdownRendererComponent,
|
|
(previous, next) =>
|
|
previous.content === next.content &&
|
|
previous.memoName === next.memoName &&
|
|
previous.compact === next.compact &&
|
|
haveEqualResolvedMentions(previous.resolvedMentionUsernames, next.resolvedMentionUsernames),
|
|
);
|