PatternsSemantic
InlineDiff
@mox-hub/patterns 模式 · Semantic · standby
inline-diff@mox-hub/patternsSemanticstandbysrc/components/inline-diff.tsx变体演示inline-diff
第一行保持不变
旧新的价格是 10080 元
最后一行保持不变
Props API
| Prop | 类型 | 默认值 | 说明 |
|---|---|---|---|
| before* | string | — | — |
| after* | string | — | — |
| onApply* | (appliedText: string) => void | — | — |
| onSegmentChange* | (decisions: DiffDecision[]) => void | — | — |
| labels* | Partial<InlineDiffLabels> | — | — |
| className* | string | — | — |
源码
/**
* InlineDiff - [AI] 文本逐段审阅件(组件规划账本 B6 · 宪法 §22.6 diff 优先律)
*
* AI 修改既有内容(文档 / 提示词 / 文案)的呈现位:默认 **diff 形态**(改前/改后对照)
* 而非替换后成品;逐段接受/拒绝;「全部接受」随时可逐段回退(应用前任一段可切回拒绝,
* 合成结果实时可预览)。
*
* - **零依赖词级 diff**:内部 LCS 对齐(token = 拉丁词 / 单个 CJK 字 / 标点 / 空白串),
* 几百词规模性能足够;超大输入(单侧 > 2000 token)退化为整段替换,不做 O(n²) 硬算。
* 纯函数 `tokenize` / `diffTextSegments` / `synthesizeAppliedText` 从本文件导出供测试与消费方复用,
* **禁引入 jsdiff 等外部 diff 依赖**(§22.6 承载件零依赖)。
* - **逐段裁决**:每个变更段(连续删除+新增构成的一段)右侧出裁决小钮(✓已接受 ↔ ✕已拒绝),
* 默认全部=接受。选钮而非「点段循环切换」的理由:二态显式钮的语义(接受=采用新增侧 /
* 拒绝=保留原文侧)一眼可辨,三态循环(接受↔拒绝↔还原)中「还原」与「拒绝」不可区分;
* 且整段点按与文本选中(复制)冲突。diff 形态恒定不随裁决变化——裁决只改合成结果与钮态。
* - **应用与回退边界**:onApply 只在点击「应用修改」时发出(不随裁决自动发出);
* **组件不做二次撤销态**——已应用后的回退由消费方持有原文实现(消费方在 onApply 前自行保存
* before,需要回退时把内容重设为保存值并重传 props 即可整体重置裁决)。本件只保证
* 应用前裁决完备(任意组合实时可预览)。
* - **受控纯展示 + 回调件**(§10.7):...props 透传到根、ref 到根(React 19 ref 即普通 prop);
* 文案缺省为中文常量(§16),消费方经 labels 覆写接入 i18n。
* - **快捷键**(仅组件聚焦时生效,焦点落入输入类控件自动让路):
* j/k 在变更段间移动焦点,Enter 切换当前段裁决(焦点在裁决钮上走 button 原生激活,无二次劫持),
* a 在「全部接受 / 全部拒绝」间切换。
* - **a11y**:容器 role="group" + aria-label(缺省「AI 修改对照」);裁决钮 aria-label 含
* 序数与裁决态(「第 2 处修改,已接受」);删除/新增不只靠颜色——<del> 删除线 + <ins> 下划线
* 附加通道(§8.5 第 4 条)。
*/
import { useMemo, useState } from 'react';
import type { KeyboardEvent } from 'react';
import { Check, X } from 'lucide-react';
import { cn } from '@mox-hub/ui';
import { Button } from '@mox-hub/ui/components/button';
import { usePatternLabels } from '../lib/i18n';
// ---------------------------------------------------------------------------
// 词级 diff 纯函数(零依赖 LCS)
// ---------------------------------------------------------------------------
export type DiffOpType = 'same' | 'del' | 'ins';
export interface DiffOp {
type: DiffOpType;
/** token 原文(含空白 token,空白串按原样保留) */
text: string;
}
/**
* 词法切分:拉丁词/数字串为一词、CJK(汉字/假名/谚文)逐字为词、
* 空白串(含换行)为一个 token、其余标点逐字为词。
* 中英混排、代码片段、全半角标点都能对齐到词粒度。
*/
const TOKEN_RE = /[A-Za-z0-9_]+|[\u3040-\u30ff\u3400-\u4dbf\u4e00-\u9fff\uac00-\ud7af\uf900-\ufaff]|\s+|[^\s]/g;
export function tokenize(text: string): string[] {
return text.match(TOKEN_RE) ?? [];
}
/** LCS 硬算上限(单侧 token 数):超过即整段替换兜底,防 O(n²) 矩阵膨胀 */
const MAX_LCS_TOKENS = 2000;
/**
* token 级 LCS 对齐:返回顺序 ops(same / del / ins)。
* 纯函数、零依赖;几百词规模(~500×500 矩阵)微秒级可完成。
*/
export function diffTokens(a: string[], b: string[]): DiffOp[] {
const m = a.length;
const n = b.length;
if (m === 0 && n === 0) return [];
if (m === 0) return b.map((text) => ({ type: 'ins' as const, text }));
if (n === 0) return a.map((text) => ({ type: 'del' as const, text }));
if (m > MAX_LCS_TOKENS || n > MAX_LCS_TOKENS) {
return [
...a.map((text) => ({ type: 'del' as const, text })),
...b.map((text) => ({ type: 'ins' as const, text })),
];
}
// dp[i][j] = a[i..] 与 b[j..] 的 LCS 长度(自底向上,Uint16 行矩阵)
const width = n + 1;
const dp = new Uint16Array((m + 1) * width);
for (let i = m - 1; i >= 0; i--) {
for (let j = n - 1; j >= 0; j--) {
dp[i * width + j] =
a[i] === b[j]
? dp[(i + 1) * width + j + 1] + 1
: Math.max(dp[(i + 1) * width + j], dp[i * width + j + 1]);
}
}
const ops: DiffOp[] = [];
let i = 0;
let j = 0;
while (i < m && j < n) {
if (a[i] === b[j]) {
ops.push({ type: 'same', text: a[i] });
i++;
j++;
} else if (dp[(i + 1) * width + j] >= dp[i * width + j + 1]) {
ops.push({ type: 'del', text: a[i] });
i++;
} else {
ops.push({ type: 'ins', text: b[j] });
j++;
}
}
while (i < m) ops.push({ type: 'del', text: a[i++] });
while (j < n) ops.push({ type: 'ins', text: b[j++] });
return ops;
}
/** 段:unchanged = 连续未变 token;changed = 连续删除+新增构成的一个「变更段」 */
export interface DiffSegment {
/** 渲染序(文档序,0 起),裁决数组以它为键 */
index: number;
type: 'unchanged' | 'changed';
/** type=unchanged:段文本;changed 恒 '' */
text: string;
/** type=changed:删除侧文本(裁决=拒绝时保留的原文片段);unchanged 恒 '' */
removed: string;
/** type=changed:新增侧文本(裁决=接受时采用的新文片段);unchanged 恒 '' */
added: string;
/** 第 N 处修改(1 起,a11y 序数);unchanged 恒 0 */
ordinal: number;
}
/**
* before/after 纯文本 → 段序列(纯函数)。
* 空白 token(含 \n)原样进段,渲染层 whitespace-pre-wrap 保持段落结构。
*/
export function diffTextSegments(before: string, after: string): DiffSegment[] {
const ops = diffTokens(tokenize(before), tokenize(after));
const segments: DiffSegment[] = [];
let unchanged = '';
let removed = '';
let added = '';
let ordinal = 0;
let index = 0;
const flushUnchanged = () => {
if (unchanged === '') return;
segments.push({ index: index++, type: 'unchanged', text: unchanged, removed: '', added: '', ordinal: 0 });
unchanged = '';
};
const flushChanged = () => {
if (removed === '' && added === '') return;
segments.push({
index: index++,
type: 'changed',
text: '',
removed,
added,
ordinal: ++ordinal,
});
removed = '';
added = '';
};
for (const op of ops) {
if (op.type === 'same') {
flushChanged();
unchanged += op.text;
} else {
flushUnchanged();
if (op.type === 'del') removed += op.text;
else added += op.text;
}
}
flushChanged();
flushUnchanged();
return segments;
}
/** 裁决初始态:全部接受(unchanged 段恒 accepted=true 且不可裁决) */
export function initialDecisions(segments: DiffSegment[]): DiffDecision[] {
return segments.map((segment) => ({
index: segment.index,
type: segment.type,
accepted: true,
}));
}
/**
* 按裁决合成应用后文本(纯函数,appliedText 口径):
* unchanged 段原样;changed 段接受取新增侧(added)、拒绝取保留侧(removed),顺序拼接。
*/
export function synthesizeAppliedText(segments: DiffSegment[], decisions: DiffDecision[]): string {
const acceptedByIndex = new Map(decisions.map((d) => [d.index, d.accepted]));
return segments
.map((segment) => {
if (segment.type === 'unchanged') return segment.text;
return acceptedByIndex.get(segment.index) === false ? segment.removed : segment.added;
})
.join('');
}
// ---------------------------------------------------------------------------
// 文案(缺省中文常量,§16;消费方经 labels 覆写接入 i18n)
// ---------------------------------------------------------------------------
export interface InlineDiffLabels {
/** 容器可访问名(role="group" 的 aria-label) */
containerLabel: string;
/** 变更段裁决钮可访问名(已接受态);{ordinal} = 第几处修改 */
segmentAccepted: string;
/** 变更段裁决钮可访问名(已拒绝态) */
segmentRejected: string;
/** 无差异占位(before 与 after 一致时整件只有这一句) */
noChanges: string;
/** 底部动作钮:全部接受 / 全部拒绝(互为反义,显示的是按下去会变成的动作) */
acceptAll: string;
rejectAll: string;
/** 预览开关(对照态钮文 / 预览态钮文)与预览区可访问名 */
preview: string;
backToDiff: string;
previewRegion: string;
/** 应用钮主文案与进度注;{total} = 变更段总数,{accepted} = 已接受数 */
apply: string;
applyProgress: string;
}
const DEFAULT_LABELS: InlineDiffLabels = {
containerLabel: 'AI 修改对照',
segmentAccepted: '第 {ordinal} 处修改,已接受',
segmentRejected: '第 {ordinal} 处修改,已拒绝',
noChanges: '两个版本内容一致,没有需要裁决的修改',
acceptAll: '全部接受',
rejectAll: '全部拒绝',
preview: '预览合成结果',
backToDiff: '返回对照',
previewRegion: '应用后的合成结果预览',
apply: '应用修改',
applyProgress: '({total} 处中已接受 {accepted} 处)',
};
/** 模板占位替换({key}),未命中原样保留 */
function tpl(template: string, vars: Record<string, string | number>): string {
return template.replace(/\{(\w+)\}/g, (_, key: string) =>
key in vars ? String(vars[key]) : `{${key}}`,
);
}
// ---------------------------------------------------------------------------
// 裁决模型
// ---------------------------------------------------------------------------
export interface DiffDecision {
/** 段序号(= DiffSegment.index,渲染序 0 起) */
index: number;
type: 'unchanged' | 'changed';
/** unchanged 段恒 true 且不可裁决;changed 段默认 true(全部=接受) */
accepted: boolean;
}
// ---------------------------------------------------------------------------
// 本体
// ---------------------------------------------------------------------------
export interface InlineDiffProps extends React.ComponentProps<'div'> {
/** 原文(纯文本,\n 分段) */
before: string;
/** AI 改后文(纯文本,\n 分段) */
after: string;
/** 「应用修改」回调:按逐段裁决合成 appliedText;不随裁决自动发出 */
onApply?: (appliedText: string) => void;
/** 裁决变化回调(逐段切换 / 全部切换都发,携带全量段决策含未变段) */
onSegmentChange?: (decisions: DiffDecision[]) => void;
/** 文案覆写(缺省中文常量) */
labels?: Partial<InlineDiffLabels>;
}
export function InlineDiff({
before,
after,
onApply,
onSegmentChange,
labels,
className,
...rest
}: InlineDiffProps) {
const providerLabels = usePatternLabels('inlineDiff', DEFAULT_LABELS);
const l = { ...providerLabels, ...labels };
const segments = useMemo(() => diffTextSegments(before, after), [before, after]);
const [decisions, setDecisions] = useState<DiffDecision[]>(() => initialDecisions(segments));
const [previewing, setPreviewing] = useState(false);
// 源文本变化(消费方换 before/after 或回退重传)→ 全部裁决与预览态整体重置
// (React 认可的「渲染期按 props 变化调整 state」模式;裁决是本件自有的交互态,非受控值缓存)
const [prevSource, setPrevSource] = useState({ before, after });
if (prevSource.before !== before || prevSource.after !== after) {
setPrevSource({ before, after });
setDecisions(initialDecisions(segments));
setPreviewing(false);
}
const changedSegments = segments.filter((s) => s.type === 'changed');
const changedDecisions = decisions.filter((d) => d.type === 'changed');
const hasChanges = changedSegments.length > 0;
const allAccepted = changedDecisions.every((d) => d.accepted);
const acceptedCount = changedDecisions.filter((d) => d.accepted).length;
const appliedText = useMemo(
() => synthesizeAppliedText(segments, decisions),
[segments, decisions],
);
const emitDecisions = (next: DiffDecision[]) => {
setDecisions(next);
onSegmentChange?.(next);
};
const toggleSegment = (index: number) => {
emitDecisions(decisions.map((d) => (d.index === index ? { ...d, accepted: !d.accepted } : d)));
};
/** a 键 / 底部互反钮:全接受 ↔ 全拒绝 */
const toggleAll = () => {
emitDecisions(
decisions.map((d) => (d.type === 'changed' ? { ...d, accepted: !allAccepted } : d)),
);
};
const handleApply = () => {
onApply?.(appliedText);
};
// 快捷键仅组件聚焦时生效(keydown 只在焦点于本件内时到达根容器);
// 焦点在输入类控件内自动让路(不抢输入框);修饰键组合不劫持。
const handleKeyDown = (event: KeyboardEvent<HTMLDivElement>) => {
if (event.ctrlKey || event.metaKey || event.altKey) return;
const target = event.target as HTMLElement | null;
if (target?.closest('input, textarea, select, [contenteditable="true"]')) return;
const toggles = Array.from(
event.currentTarget.querySelectorAll<HTMLButtonElement>(
'[data-segment-type="changed"] button',
),
);
if (toggles.length === 0) return;
if (event.key === 'j' || event.key === 'k') {
event.preventDefault();
const current = toggles.indexOf(document.activeElement as HTMLButtonElement | null);
const next =
event.key === 'j'
? Math.min(current + 1, toggles.length - 1)
: Math.max(current - 1, 0);
toggles[current === -1 ? 0 : next].focus();
} else if (event.key === 'a' || event.key === 'A') {
event.preventDefault();
toggleAll();
}
};
return (
<div
data-slot="inline-diff"
data-ai-component="inline-diff"
role="group"
aria-label={l.containerLabel}
tabIndex={0}
onKeyDown={handleKeyDown}
className={cn(
'rounded-lg border bg-card px-4 py-3',
'focus-visible:outline-2 focus-visible:outline-offset-2 focus-visible:outline-ring',
className,
)}
{...rest}
>
<div
data-slot="inline-diff-body"
className="whitespace-pre-wrap break-words text-sm leading-relaxed text-content-text"
>
{previewing ? (
<div data-slot="inline-diff-preview" aria-label={l.previewRegion}>
{appliedText}
</div>
) : (
segments.map((segment) => {
if (segment.type === 'unchanged') {
return (
<span
key={segment.index}
data-slot="inline-diff-segment"
data-segment-type="unchanged"
>
{segment.text}
</span>
);
}
const accepted = decisions.find((d) => d.index === segment.index)?.accepted ?? true;
return (
<span
key={segment.index}
data-slot="inline-diff-segment"
data-segment-type="changed"
data-change-ordinal={segment.ordinal}
data-accepted={accepted ? 'true' : 'false'}
>
{segment.removed ? (
// §8.5 第 4 条:删除不只靠颜色——<del> 删除线为附加通道
<del className="rounded-xs bg-accent-red-light/70 px-0.5 text-accent-red line-through decoration-accent-red/60">
{segment.removed}
</del>
) : null}
{segment.added ? (
// §8.5 第 4 条:新增不只靠颜色——<ins> 下划线为附加通道
<ins
className={cn(
'rounded-xs bg-accent-green-light/70 px-0.5 text-accent-green underline decoration-accent-green/60',
segment.removed && 'ms-1',
)}
>
{segment.added}
</ins>
) : null}
{/* 逐段裁决钮:显式二态(✓已接受 ↔ ✕已拒绝),icon 形状即状态(§8.5 第 4 条) */}
<Button
type="button"
variant="ghost"
size="icon-2xs"
aria-label={
accepted
? tpl(l.segmentAccepted, { ordinal: segment.ordinal })
: tpl(l.segmentRejected, { ordinal: segment.ordinal })
}
aria-pressed={accepted}
onClick={() => toggleSegment(segment.index)}
className={cn(
'mx-1 align-middle',
accepted ? 'text-accent-green' : 'text-accent-red',
)}
>
{accepted ? (
<Check aria-hidden="true" />
) : (
<X aria-hidden="true" />
)}
</Button>
</span>
);
})
)}
</div>
{hasChanges ? (
<div
data-slot="inline-diff-actions"
className="mt-3 flex flex-wrap items-center gap-2 border-t border-border/60 pt-3"
>
<Button type="button" variant="ghost" size="xs" onClick={toggleAll}>
{allAccepted ? l.rejectAll : l.acceptAll}
</Button>
<Button
type="button"
variant="ghost"
size="xs"
aria-pressed={previewing}
onClick={() => setPreviewing((prev) => !prev)}
>
{previewing ? l.backToDiff : l.preview}
</Button>
<span className="flex-1" />
<Button type="button" size="xs" onClick={handleApply}>
{l.apply}
<span className="font-normal text-content-text-muted">
{tpl(l.applyProgress, { total: changedSegments.length, accepted: acceptedCount })}
</span>
</Button>
</div>
) : (
<p data-slot="inline-diff-nochanges" className="mt-2 text-xs text-content-text-muted">
{l.noChanges}
</p>
)}
</div>
);
}
可访问性与 RTL
- 键盘:交互件保留
:focus-visible焦点环;浮层支持 Escape 关闭与焦点归还,菜单 / 页签按 Base UI 约定支持方向键。 筛选菜单、拖拽排序、执行树与模型 listbox 等关键键盘流由 Playwright 断言覆盖,见规范示例 · 交互与可访问性。 - RTL:间距、对齐与方向性图标使用逻辑属性 (
ms-*/text-start/rtl:-scale-x-100);通过ThemeProvider或I18nProvider的direction="rtl"驱动,`lint:rtl` 会拦截新增物理类。 - 文案:优先用组件
labels/translate/translatorprops,其次用I18nProvider目录;内置 zh-CN 默认值,en-US 为参考翻译。见Theming · i18n 与 RTL。 - 对比度:高对比度 token、2px 控件边框与 3px 焦点环由主题层统一提供,见Foundations · Contrast。
用法说明
行内文本差异视图:逐行 diff + 增删高亮,纯展示;数据为旧/新文本对,折叠与行号策略由 props 控制。