An open-source, privacy-first, self-hosted knowledge workspace where humans and AI agents work together 开源、隐私优先、自托管的知识工作空间,让人与智能体在此协作
TypeScript agentic-aiai-agentknowledge-baselocal-firstmarkdownmcpmindmapnote-takingself-hostedsiyuanworkspace
import * as assert from "node:assert/strict";
import {execFile} from "node:child_process";
import {mkdtempSync, readFileSync, rmSync, writeFileSync} from "node:fs";
import {tmpdir} from "node:os";
import * as path from "node:path";
import {test} from "node:test";
import {createSourceFile, isVariableStatement, ModuleKind, ScriptTarget, transpileModule} from "typescript";
import {promisify} from "node:util";
const browserCases = async (source: string, pasteSource: string) => {
const check: typeof assert = require("node:assert/strict");
const noop = () => {};
const transactions: {before: string, after: string}[] = [];
const dependencies = {
Constants: {ZWSP: "\u200b"}, dayjs: () => ({format: () => "20261020000000"}),
getTextWithoutSemanticMarkers: (node: Node) => node.textContent,
updateTransaction: (_owner: IProtyle, block: HTMLElement, before: string) => {
transactions.push({before, after: block.outerHTML});
},
setLastNodeRange: (cell: Element, range: Range) => range.selectNodeContents(cell),
};
const api = new Function(...Object.keys(dependencies), source + "\nreturn {getAgentLute, configureAVRichTextLute, " +
"getAVRichTextUnsupportedPasteBlocks, getTableClipboardBlockDOM, getTableRangeHTML, processTable, getTablePasteTarget, " +
"hasClosestBlock, getTableCellRichContext, setTableCellRichContext, restoreTableVirtualizationDOM, " +
"setTableCellRich, getTableCellRichBlockDOM, markdownMathPaste, htmlMathPaste};")(...Object.values(dependencies)) as
typeof import("../render/setLute") & typeof import("../render/av/richText") & typeof import("./table") &
typeof import("./hasClosest") & typeof import("./tableCellRichContext") & typeof import("./tableCellRich") &
typeof import("./tableVirtualizationDOM") & typeof import("./mathPaste") & {
processTable: (range: Range, html: string, protyle: IProtyle, block: HTMLElement, target: unknown) => boolean,
getTablePasteTarget: (range: Range) => unknown,
};
Object.assign(window, {siyuan: {languages: {table: "Table", cellPasteUnsupported: "Unsupported: ${x}"},
config: {editor: {markdown: {}}}}});
const lute = api.configureAVRichTextLute(api.getAgentLute({emojiSite: "/emojis", emojis: {},
headingAnchor: false, listStyle: false, paragraphBeginningSpace: true, sanitize: true}));
let cellEditor: IProtyle;
let rejected = 0;
const focusByRange = (range: Range) => {
getSelection().removeAllRanges();
getSelection().addRange(range);
};
const mocks: Record<string, unknown> = {
"../../constants": {Constants: dependencies.Constants},
"../../util/pathName": {isEncryptedBox: () => false},
"./tableCellRichContext": api, "./hasClosest": api, "./tableVirtualizationDOM": api,
"../runtimeCapabilities": {
getProtyleBlockDOMSanitizer: (protyle: IProtyle) => protyle === cellEditor ? (html: string) => html : undefined,
getProtyleUnsupportedPasteBlocks: () => (html: string) => {
if (html.includes("ordinary")) {
throw new Error("ordinary cell paste");
}
return api.getAVRichTextUnsupportedPasteBlocks(html, true);
},
isProtyleRichHTMLPasteEnabled: () => true, isProtyleUploadDisabled: () => true,
areProtylePluginExtensionsEnabled: () => false,
},
"../upload/insertPosition": {
createUploadInsertPosition: (range: Range) => ({range: range.cloneRange()}),
captureUploadDocument: () => ({}),
isUploadInsertPositionAvailable: (_editor: Element, position: {range: Range}) => position.range.startContainer.isConnected,
getAvailableUploadInsertRange: (_editor: Element, position: {range: Range}) => position.range,
},
"./selection": {getEditorRange: () => getSelection().getRangeAt(0)},
"./selectionOffsets": {focusByRange},
"./compatibility": {isInHarmony: () => false,
getTextSiyuanFromTextHTML: (html: string) => ({textSiyuan: "", textHtml: html})},
"./officeMath": {extractOfficeMathHTML: () => ""},
"./wpsPresentation": {extractWPSPresentationClipboard: (): undefined => undefined},
"./markdownClipboard": {shouldPasteMarkdownFromHTML: () => false},
"./processCode": {processPasteCode: () => "", processRender: noop},
"../ui/hideElements": {hideElements: noop},
"../render/blockRender": {blockRender: noop}, "../render/highlightRender": {highlightRender: noop},
"../render/av/render": {avRender: noop}, "../../util/highlightById": {scrollCenter: noop},
"./inlineElementMarker": {normalizeSemanticInlineElements: noop, stripSemanticMarkersFromRangeText: () => ""},
"./clear": {clearBlockElement: noop}, "./tabsCopy": {wrapPastedTabItems: noop, remapTabsDOMIDs: noop},
"../render/listMindmap/model": {remapListMindmapIDs: noop},
"../render/embedRenderState": {resetPastedQueryEmbedRenderState: noop},
"./pasteSource": {extractCrossBlockPasteContext: (_html: string) => ({nestedList: false, html: _html}),
shouldPreservePastedBlockStructure: () => false, serializePastedBlockDOM: (element: Element) => element.innerHTML},
"../../util/fetch": {fetchSyncPost: async () => ({code: 0, data: {}})},
"../../dialog/message": {showMessage: () => { rejected++; }},
"../../util/escape": {escapeHtml: (text: string) => text},
"dayjs": dependencies.dayjs,
"./insertHTML": {insertHTML: (html: string, owner: IProtyle) => {
const range = owner.toolbar.range;
const block = api.hasClosestBlock(range.startContainer) as HTMLElement;
check.equal(api.processTable(range, html, owner, block, api.getTablePasteTarget(range)), true);
}},
"./mathPaste": {markdownMathPaste: api.markdownMathPaste, htmlMathPaste: api.htmlMathPaste},
};
const exports = {};
new Function("exports", "require", pasteSource)(exports, (id: string) => mocks[id] || {});
const pasteAPI = exports as typeof import("./paste");
for (const mode of ["internal", "single", "native", "html", "markdown", "merged", "rich",
"composing", "disabled", "removed", "mixed", "ordinary"]) {
const ownerElement = document.createElement("div");
const editor = document.createElement("div");
editor.className = "protyle-wysiwyg";
editor.contentEditable = "true";
editor.innerHTML = lute.Md2BlockDOM("| H1 | H2 | H3 |\n| --- | --- | --- |\n| old | keep | tail |\n| last | end | stay |");
ownerElement.append(editor);
document.body.append(ownerElement);
const table = editor.firstElementChild as HTMLElement;
const grid = table.querySelector("table");
const cell = grid.rows[1].cells[0];
const original = table.outerHTML;
const host = document.createElement("div");
host.className = "table__cell-editor";
host.innerHTML = '<div class="protyle-wysiwyg"><div data-node-id="cell" data-type="NodeParagraph" class="p">' +
'<div contenteditable="true">old</div></div></div>';
cell.replaceChildren(host);
const owner = {element: ownerElement, wysiwyg: {element: editor}, toolbar: {getCurrentType: (): string[] => []},
hint: {enableExtend: false}, lute, disabled: mode === "disabled"} as unknown as IProtyle;
cellEditor = {element: host, wysiwyg: {element: host.firstElementChild}, toolbar: {}, lute} as unknown as IProtyle;
let finishes = 0;
api.setTableCellRichContext(cellEditor, {owner, cell, finish: () => {
finishes++;
if (mode !== "composing") {
cell.innerHTML = "old";
}
if (mode === "removed") {
ownerElement.remove();
}
}});
const range = document.createRange();
range.selectNodeContents(host.querySelector('[contenteditable="true"]'));
range.collapse(false);
focusByRange(range);
const source = document.createElement("div");
source.innerHTML = api.getTableClipboardBlockDOM(mode === "single" ? "<table><tr><td>a</td></tr></table>" : mode === "merged" ?
'<table><tbody><tr><td colspan="2">a</td><td class="fn__none"></td></tr><tr><td>b</td><td>c</td></tr></tbody></table>' :
'<table><tbody><tr><td><span data-type="strong">a</span></td><td>b</td></tr><tr><td>c</td><td>d</td></tr></tbody></table>');
if (mode === "rich") {
api.setTableCellRich(source.querySelector("td"), "first\n\n- second");
}
const tableHTML = source.innerHTML;
const clipboard = mode === "html" ? {textHTML: "<table><tr><td>a</td><td>b</td></tr><tr><td>c</td><td>d</td></tr></table>", siyuanHTML: ""} :
mode === "markdown" ? {textHTML: "", siyuanHTML: ""} :
{textHTML: "", siyuanHTML: mode === "mixed" ? tableHTML + lute.Md2BlockDOM("extra") :
mode === "ordinary" ? lute.Md2BlockDOM("ordinary") : tableHTML};
transactions.length = 0;
rejected = 0;
// 普通文本应继续走内部编辑器;本用例只检查路由,不替代其插入测试。
if (mode === "ordinary") {
await check.rejects(pasteAPI.paste(cellEditor, {target: host.querySelector("[contenteditable]"),
textPlain: "ordinary", ...clipboard}), /ordinary cell paste/);
check.equal(finishes, 0);
} else {
const payload = {target: host.querySelector<HTMLElement>("[contenteditable]"),
textPlain: "| a | b |\n| --- | --- |\n| c | d |", ...clipboard};
if (mode === "native") {
const data = new DataTransfer();
data.setData("text/siyuan", clipboard.siyuanHTML);
data.setData("text/plain", payload.textPlain);
const event = new ClipboardEvent("paste", {clipboardData: data, bubbles: true, cancelable: true});
let pending: Promise<void>;
payload.target.addEventListener("paste", event => {
pending = pasteAPI.paste(cellEditor, event as ClipboardEvent & {target: HTMLElement});
}, {once: true});
payload.target.dispatchEvent(event);
await pending;
check.equal(event.defaultPrevented, true);
} else {
await pasteAPI.paste(cellEditor, payload);
}
if (mode === "mixed") {
check.equal(rejected, 1);
check.equal(finishes, 0);
} else if (mode === "disabled" || mode === "removed") {
check.equal(finishes, mode === "disabled" ? 0 : 1);
check.equal(transactions.length, 0);
} else if (mode === "composing") {
check.equal(finishes, 1);
check.ok(cell.contains(host));
check.equal(transactions.length, 0);
} else {
check.equal(rejected, 0, mode);
check.equal(finishes, 1, mode);
check.equal(transactions.length, 1, mode);
check.equal(grid.querySelector("table"), null, "pasting never nests a table");
check.equal(grid.rows[1].cells[2].textContent, "tail");
check.equal(grid.rows[2].cells[2].textContent, "stay");
if (mode === "rich") {
check.equal(cell.getAttribute("data-sy-table-cell-rich"),
source.querySelector("td").getAttribute("data-sy-table-cell-rich"));
} else {
check.equal(cell.textContent, "a");
}
check.equal(grid.rows[2].cells[0].textContent, mode === "single" ? "last" : mode === "merged" ? "b" : "c");
check.equal(grid.rows[2].cells[1].textContent, mode === "single" ? "end" : mode === "merged" ? "c" : "d");
check.equal(transactions[0].before, original, "undo starts from the committed outer table");
check.doesNotMatch(transactions[0].after, /table__cell-editor/);
}
}
ownerElement.remove();
}
return "table-cell-paste-ok";
};
test("table clipboard fills the outer grid while a cell editor is active", {timeout: 30000}, async () => {
const read = (name: string) => readFileSync(path.join(__dirname, name), "utf8");
const compile = (source: string) => transpileModule(source.replace(/^import [\s\S]*?;\r?\n/gm, "")
.replace(/^export (?:type )?\{[\s\S]*?\}(?: from "[^"]+")?;\r?\n/gm, "")
.replace(/^export /gm, ""), {compilerOptions: {target: ScriptTarget.ES2022}}).outputText;
const insert = createSourceFile("insertHTML.ts", read("insertHTML.ts"), ScriptTarget.Latest, true);
const processTable = insert.statements.filter(isVariableStatement).filter(statement =>
statement.declarationList.declarations.some(declaration =>
["getTablePasteTarget", "processTable"].includes(declaration.name.getText(insert))))
.map(statement => statement.getText(insert)).join("\n");
const source = ["longTextWrap.ts", "inlineElementBoundary.ts", "../toolbar/fontFamilyCore.ts", "../../util/escape.ts",
"../render/setLute.ts", "../render/av/richTextValue.ts", "../render/av/richText.ts", "tableCellRichValue.ts",
"tableCellRich.ts", "tableCellRichContext.ts", "tableVirtualizationDOM.ts", "hasClosest.ts", "table.ts", "mathPaste.ts"]
.map(name => compile(read(name))).join("\n") + "\n" + compile(processTable);
const pasteSource = transpileModule(read("paste.ts"), {
compilerOptions: {target: ScriptTarget.ES2022, module: ModuleKind.CommonJS},
}).outputText;
const directory = mkdtempSync(path.join(tmpdir(), "siyuan-table-cell-paste-"));
const script = path.join(directory, "main.cjs");
const execute = `const __name = value => value; (${browserCases.toString()})(${JSON.stringify(source)}, ${JSON.stringify(pasteSource)})`;
writeFileSync(script, `const {app, BrowserWindow} = require("electron");
app.setPath("userData", ${JSON.stringify(path.join(directory, "profile"))});
app.whenReady().then(async () => {
const win = new BrowserWindow({show: false, webPreferences: {nodeIntegration: true, contextIsolation: false, offscreen: true}});
try {
await win.loadURL("about:blank");
await win.webContents.executeJavaScript(require("node:fs").readFileSync(${JSON.stringify(path.resolve("stage/protyle/js/lute/lute.min.js"))}, "utf8"));
console.log(await win.webContents.executeJavaScript(${JSON.stringify(execute)}));
app.exit(0);
} catch (error) { console.error(error); app.exit(1); }
});`);
try {
const env = {...process.env};
delete env.ELECTRON_RUN_AS_NODE;
const result = await promisify(execFile)(require("electron") as unknown as string, [script],
{env, timeout: 25000, windowsHide: true});
assert.match(result.stdout, /table-cell-paste-ok/);
} finally {
if (path.dirname(path.resolve(directory)) === path.resolve(tmpdir()) &&
path.basename(directory).startsWith("siyuan-table-cell-paste-")) {
rmSync(directory, {recursive: true, force: true});
}
}
});