dsh-better-chat/tests/fixtures/reader-official-users.tsx

235 lines
13 KiB
TypeScript

import { Context } from '@deepseek-ai/cordis';
import * as React from 'react';
import * as Primitives from '@deepseek-ai/dsh-client-ui-primitives';
import { createRoot } from 'react-dom/client';
import { flushSync } from 'react-dom';
import { SlotRegistry } from '@fixture/registry';
import { createSlotRenderer } from '@fixture/renderer';
import { Reader } from '../../src/client/Reader.js';
import { createReaderStore } from '../../src/client/store.js';
import { installOfficialSlots, officialChildren, OFFICIAL_SEATS } from '../../src/client/official-slots.js';
import type { ReaderProps } from '../../src/client/types.js';
// Real Reader, registry, scope binding and slot renderer. Only session data is synthetic.
function equal(actual: unknown, expected: unknown) {
if (!Object.is(actual, expected)) throw new Error(`Expected ${String(expected)}, got ${String(actual)}`);
}
const assert = {
equal,
ok(value: unknown) { equal(Boolean(value), true); },
deepEqual(actual: unknown, expected: unknown) { equal(JSON.stringify(actual), JSON.stringify(expected)); },
};
async function verify() {
const root = new Context();
await root.plugin(SlotRegistry);
let run = async () => {};
await root.plugin({ name: 'reader-user-test', inject: ['slots'], async apply(ctx: Context) {
const slots = ctx.slots as any;
slots.install(createSlotRenderer());
const source = <T,>(value: T) => ({ getSnapshot: () => value, subscribe: () => () => {} });
const binding = { key: 'session-users', ctx: new Context(), hooks: {}, keyedHooks: {}, props: { sessionId: 'session-users' } };
slots.installScope('session', {
current: source(binding), bindingSource: () => source(binding), renderArea: (_: unknown, props: any) => props.children,
});
slots.installLocale({ ...source({}), bind: () => (key: string) => key });
const turn = { turn: 1, status: 'closed', start: { seq: 1, time: 1 },
end: { time: 2, data: { reason: { kind: 'completed' } } }, data: new Map(), steps: [] };
const nodes = new Map(['user', 'steering', 'hidden'].map((kind, index) => {
const key = `${kind}-key`;
return [key, { key, kind: kind === 'hidden' ? 'user' : kind, anchorSeq: index + 1,
visibility: kind === 'hidden' ? 'hidden' : 'visible', location: { kind: 'turn', turn },
data: { seq: index + 1, time: 1, content: [{ type: 'text', text: `${kind} content` }] } }];
}));
const chat = { order: [...nodes.keys()], nodes, timeline: { turns: new Map([[1, turn]]) } };
const session = { running: false, openState: 'ready', pendingSubmissions: [], hasMore: false, loadingOlder: false };
const store = createReaderStore().create('session-users');
const props = {
sessionId: 'session-users', useChat: (select: any) => select(chat),
useSession: (select: any) => select(session), useSessions: (select: any) => select({ byId: { 'session-users': { cwd: '/fixture' } } }),
useSessionStatus: (select: any) => select(new Map()), useStore: (select: any) => select(store.getSnapshot()), actions: store.actions,
t: (key: string) => key, loadImage: async () => ({ data: new Uint8Array(), mediaType: 'image/png' }),
officialImageLoader: Object.assign(async () => null, { peek: () => null }),
officialFileMentions: () => undefined, officialPreviewFile: () => {},
officialHost: source({ home: '/fixture' }), fillComposer: () => true,
openFile: () => {}, loadOlder: async () => {}, openView: () => {},
};
slots.register({ name: 'root', children: {
'conversation.chat.node': { kind: 'keyed', scope: 'session', inject: { hooks: {
turnData: (_: unknown, context: any) => () => context.turnData,
disclosure: (_: unknown, context: any) => () => context.disclosureReset,
} } },
'fixture.reader': { kind: 'single', scope: 'session' },
} }, ({ SessionProvider, renderSlot }: any) => <SessionProvider>{renderSlot('fixture.reader', {})}</SessionProvider>);
slots.register({ name: 'fixture.reader', children: { ...officialChildren(slots), 'dsh-better-display.block': { kind: 'chain', scope: 'session' } } }, ({ renderSlot, renderSlotChain }: any) =>
<Reader {...{ ...props, renderSlot, renderSlotChain } as ReaderProps} />);
const stopMirror = installOfficialSlots(ctx);
run = async () => {
const container = document.getElementById('app')!;
const reactRoot = createRoot(container);
const render = () => {
flushSync(() => reactRoot.render(slots.renderSlot('root', {})));
return container.innerHTML;
};
const count = (html: string, text: string) => html.split(text).length - 1;
const assertSeats = (html: string) => {
for (const kind of ['user', 'steering']) {
assert.equal(count(html, `data-reader-key="${kind}-key"`), 1);
assert.equal(count(html, `data-chat-anchor-key="${kind}-key"`), 1);
assert.equal(count(html, `data-chat-flow-key="${kind}-key"`), 1);
assert.equal(count(html, `data-chat-node-key="${kind}-key"`), 1);
assert.equal(count(html, `data-chat-flow-kind="${kind}"`), 1);
}
assert.equal(count(html, 'data-reader-anchor="true"'), 2);
assert.ok(!html.includes('hidden content'));
};
// The real renderSlot returns an outlet element for an unoccupied key.
let html = render();
assertSeats(html);
assert.equal(count(html, 'user content'), 1);
assert.equal(count(html, 'steering content'), 1);
assert.ok(html.includes('补充消息'));
const seen: any[] = [];
const official = ({ node, sessionId, injectedSession, useTurnData, useDisclosure }: any) => {
assert.equal(sessionId, 'session-users');
assert.equal(injectedSession, 'session-users');
assert.equal(useTurnData(), turn.data);
assert.equal(useDisclosure().getSnapshot(), 0);
assert.equal(node, nodes.get(node.key));
seen.push(node.kind);
return <div data-official-user={node.kind}>{node.data.content[0].text}<button>Official recall</button></div>;
};
const removeUser = slots.register({ name: 'conversation.chat.node', key: 'user',
inject: (sessionId: string) => ({ injectedSession: sessionId }), locale: 'chat' }, official);
const removeSteering = slots.register({ name: 'conversation.chat.node', key: 'steering',
inject: (sessionId: string) => ({ injectedSession: sessionId }), locale: 'chat' }, official);
const removeAssistant = slots.register({ name: 'conversation.chat.node', key: 'assistant-step' }, () => <span>Duplicate assistant</span>);
await new Promise(resolve => queueMicrotask(resolve));
assert.deepEqual(slots.entriesOfSlot(OFFICIAL_SEATS.nodes).map((entry: any) => entry.options.key).sort(), ['steering', 'user']);
html = render();
assertSeats(html);
assert.equal(count(html, 'Official recall'), 2);
assert.equal(count(html, 'user content'), 1);
assert.equal(count(html, 'steering content'), 1);
assert.deepEqual(seen, ['user', 'steering']);
// A winner intentionally returning null must keep its row hidden.
const removeWinner = slots.register({ name: 'conversation.chat.node', key: 'user', priority: -1 }, () => null);
await new Promise(resolve => queueMicrotask(resolve));
html = render();
assertSeats(html);
assert.equal(count(html, 'user content'), 0);
assert.equal(count(html, 'Official recall'), 1);
removeWinner();
await new Promise(resolve => queueMicrotask(resolve));
assert.equal(count(render(), 'Official recall'), 2);
removeUser(); removeSteering(); removeAssistant();
await new Promise(resolve => queueMicrotask(resolve));
html = render();
assertSeats(html);
assert.equal(count(html, 'user content'), 1);
assert.equal(count(html, 'steering content'), 1);
assert.equal(count(html, 'Official recall'), 0);
// A priority below the official assistant renderer is a replacement.
// Reader keeps the reasoning card and hands only the body blocks over.
const assistant = {
key: 'assistant-key', kind: 'assistant-step', anchorSeq: 4, visibility: 'visible',
location: { kind: 'turn', turn },
data: {
status: 'settled', turn: 1, step: 0, time: 3,
blocks: [
{ kind: 'reasoning', text: 'think privately' },
{ kind: 'text', text: '<div id="vcp-root">card face</div>' },
],
},
};
// Reader memoizes on the order array and the nodes map. A real host
// publishes new references; this fixture has to do the same.
chat.nodes = new Map(chat.nodes);
chat.nodes.set('assistant-key', assistant);
chat.order = [...chat.order, 'assistant-key'];
store.actions.setExpanded('turn:1:closed:completed', true);
html = render();
assert.equal(count(html, 'data-foreign-assistant'), 0);
assert.ok(html.includes('vcp-root'));
assert.ok(html.includes('think privately'));
const calls: Array<{ groupPart: unknown; kinds: string[]; text: string }> = [];
const Foreign = (props: { groupPart?: unknown; node?: { data?: { blocks?: Array<{ kind: string; text?: string }> } } }) => {
const blocks = props.node?.data?.blocks ?? [];
calls.push({
groupPart: props.groupPart,
kinds: blocks.map(block => block.kind),
text: blocks.map(block => block.text ?? '').join('\n'),
});
const body = blocks.filter(block => block.kind === 'text').map(block => block.text ?? '').join('\n');
return <div data-foreign-assistant>{body}</div>;
};
const removeOfficialAssistant = slots.register({ name: 'conversation.chat.node', key: 'assistant-step' }, () => <span>Official assistant</span>);
const removeForeign = slots.register({ name: 'conversation.chat.node', key: 'assistant-step', priority: -10 }, Foreign);
await new Promise(resolve => queueMicrotask(resolve));
assert.ok(slots.entriesOfSlot(OFFICIAL_SEATS.nodes).some((entry: { options: { key?: string; priority?: number } }) => entry.options.key === 'assistant-step' && entry.options.priority === -10));
html = render();
const answer = container.querySelector('[data-reader-body]');
assert.ok(answer);
assert.equal(answer!.querySelectorAll('[data-foreign-assistant]').length, 1);
assert.ok(answer!.textContent?.includes('<div id="vcp-root">card face</div>'));
assert.equal(answer!.querySelectorAll('pre').length, 0);
assert.equal(count(html, 'Official assistant'), 0);
assert.ok(calls.some(call => call.groupPart === 'response' && call.kinds.join(',') === 'text' && call.text.includes('vcp-root')));
assert.ok(calls.every(call => !call.kinds.includes('reasoning')));
const reasoning = container.querySelector('[data-reader-text-kind="reasoning"]');
assert.ok(reasoning);
assert.ok(reasoning!.textContent?.includes('think privately'));
assert.equal(reasoning!.querySelectorAll('[data-foreign-assistant]').length, 0);
removeForeign();
removeOfficialAssistant();
await new Promise(resolve => queueMicrotask(resolve));
html = render();
assert.equal(count(html, 'data-foreign-assistant'), 0);
assert.ok(html.includes('vcp-root'));
assert.ok(html.includes('think privately'));
chat.nodes = new Map(chat.nodes);
chat.nodes.delete('assistant-key');
chat.order = chat.order.filter((key: string) => key !== 'assistant-key');
store.actions.setExpanded('turn:1:closed:completed', false);
const module = Reflect.get(window, 'easyrewriteModule');
if (module) {
const plugin = module.factory((name: string) => {
if (name === 'react') return React;
if (name === '@deepseek-ai/dsh-client-ui-primitives') return Primitives;
throw new Error(`Unexpected easyrewrite dependency: ${name}`);
});
const disposers: Array<() => void> = [];
plugin.apply({
effect: (effect: () => () => void) => disposers.push(effect()),
slots: {
inject: (key: string, effect: () => () => void) => key === 'conversation.chat.node' ? effect() : () => {},
register: (options: object, component: unknown) => slots.register(options, component),
},
sessions: { list: source({ current: 'session-users' }), scope: () => ({ get: () => undefined }) },
workspaces: {},
});
await new Promise(resolve => queueMicrotask(resolve));
html = render();
assertSeats(html);
assert.equal(count(html, 'data-dsh-easyrewrite="user"'), 1);
assert.equal(count(html, 'data-dsh-easyrewrite="recall-key"'), 1);
assert.equal(count(html, 'user content'), 1);
assert.equal(count(html, 'steering content'), 1);
const recall = container.querySelector<HTMLButtonElement>('[data-dsh-easyrewrite="recall-key"]');
assert.ok(recall);
flushSync(() => recall!.click());
assert.equal(container.querySelectorAll('[data-dsh-easyrewrite="confirm-capsule"]').length, 1);
for (const dispose of disposers) dispose();
}
stopMirror();
reactRoot.unmount();
Object.assign(window, { readerUserResult: 'passed' });
};
} });
await run();
}
verify().catch(error => { console.error(error); Object.assign(window, { readerUserResult: `${error.stack}\n${document.getElementById('app')?.innerHTML}` }); });