Skip to content

An open-source, privacy-first, self-hosted knowledge workspace where humans and AI agents work together 开源、隐私优先、自托管的知识工作空间,让人与智能体在此协作

9.5 KB
Raw Blame
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 {promisify} from "node:util";
import {createSourceFile, isVariableStatement, ModuleKind, ScriptTarget, transpileModule} from "typescript";

const browserCases = (sources: Record<string, string>, tagSource: string, focusSource: string) => {
    const check: typeof assert = require("node:assert/strict");
    const modules: Record<string, {exports: any}> = {};
    const load = (name: string) => {
        if (modules[name]) {
            return modules[name].exports;
        }
        const module = {exports: {}};
        modules[name] = module;
        new Function("require", "module", "exports", sources[name])((dependency: string) => {
            const parts = name.split("/");
            parts.pop();
            dependency.split("/").forEach(part => {
                if (part === "..") {
                    parts.pop();
                } else if (part !== ".") {
                    parts.push(part);
                }
            });
            return load(parts.join("/"));
        }, module, module.exports);
        return module.exports;
    };
    const marker: typeof import("../protyle/util/inlineElementMarker") = load("protyle/util/inlineElementMarker");
    const boundary: typeof import("../protyle/util/inlineElementBoundary") = load("protyle/util/inlineElementBoundary");
    const Constants = {WORD_JOINER: "\u2060", ZWSP: "\u200b", MENU_INLINE_TAG: "tag", ATTRIBUTE_MENU_KEYMAP: "data-keymap"};
    const focusByRange = (range: Range) => {
        getSelection().removeAllRanges();
        getSelection().addRange(range);
    };
    const focusByWbr = new Function("Constants", "getSemanticMarkerPrefixLengthForNode", "hasPreviousSibling",
        "focusByRange", focusSource + "\nreturn focusByWbr;")(Constants, marker.getSemanticMarkerPrefixLengthForNode,
        (element: Element) => element.previousSibling, focusByRange);
    const lute = boundary.protectLuteInlineElementBoundaries(Lute.New());
    lute.SetTextMark(true);
    lute.SetTag(true);
    lute.SetKramdownIAL(true);
    lute.SetSpin(true);
    lute.SetProtyleWYSIWYG(true);
    const paragraph = (html: string) => '<div data-type="NodeParagraph" data-node-id="20261002180000-abcdefg" class="p">' +
        `<div contenteditable="true">${html}</div><div class="protyle-attr" contenteditable="false"></div></div>`;

    for (const operation of ["clear", "remove"]) {
        for (const surrounding of ["", "before\u2060", '<span data-type="code">neighbor</span>']) {
            const menuElement = document.createElement("div");
            document.body.append(menuElement);
            const options = new Map<string, IMenu>();
            const menu = {element: menuElement, removeCB: undefined as (() => void), remove() {},
                append: (element: Element) => menuElement.append(element), fullscreen() {}, popup() {}};
            Object.assign(window, {siyuan: {menus: {menu}, languages: {tag: "Tag"}}});
            class MenuItem {
                element: HTMLElement;
                constructor(option: IMenu) {
                    options.set(option.id, option);
                    this.element = document.createElement("div");
                    this.element.innerHTML = option.label || "";
                    option.bind?.(this.element);
                }
            }
            const editor = document.createElement("div");
            editor.contentEditable = "true";
            editor.innerHTML = paragraph('<span data-type="tag">example</span>' + surrounding);
            document.body.append(editor);
            const block = editor.firstElementChild;
            const content = block.firstElementChild;
            marker.normalizeSemanticInlineElements(content);
            const tag = content.querySelector<HTMLElement>('[data-type="tag"]');
            check.ok(tag.hasAttribute("data-inline-boundary"));
            let transaction = "";
            const dependencies = {
                Constants, MenuItem, focusByWbr, focusByRange,
                ...marker,
                hasClosestBlock: (element: Element) => element.closest('[data-type="NodeParagraph"]'),
                hideElements() {}, dayjs: () => ({format: () => "20261002180000"}),
                updateTransaction(_protyle: IProtyle, element: Element) {
                    transaction = boundary.restoreInlineElementBoundaryHTML(element.outerHTML);
                },
                emitOpenMenu() {}, hasTopClosestByClassName: (): null => null,
            };
            const tagMenu = new Function(...Object.keys(dependencies), tagSource + "\nreturn tagMenu;")(
                ...Object.values(dependencies));
            const range = document.createRange();
            range.selectNodeContents(tag);
            tagMenu({element: editor, toolbar: {range}}, tag);
            if (operation === "clear") {
                menuElement.querySelector("input").value = "";
                menu.removeCB();
            } else {
                options.get("remove").click(undefined, undefined);
            }
            check.equal(content.querySelector('[data-type="tag"]'), null);
            check.equal(range.collapsed, true);
            check.ok(content.contains(range.startContainer));
            const template = document.createElement("template");
            template.innerHTML = lute.SpinBlockDOM(transaction);
            const savedContent = template.content.querySelector('[contenteditable="true"]');
            if (surrounding === "") {
                check.equal(content.textContent, "", operation);
                check.equal(savedContent.textContent, "", operation);
                for (const [input, type] of [["- item", "NodeList"], ["> quote", "NodeBlockquote"]]) {
                    check.ok(lute.SpinBlockDOM(paragraph(savedContent.textContent + input)).includes(`data-type="${type}"`));
                }
            } else if (surrounding.startsWith("before")) {
                check.equal(content.textContent, "before\u2060");
                check.equal(savedContent.textContent, "before\u2060");
            } else {
                check.equal(marker.getSemanticInlineVisibleText(content.querySelector("span")), "neighbor");
                check.equal(savedContent.querySelector("span").getAttribute("data-type"), "code");
                check.equal(savedContent.textContent.replace(/[\u200b\u2060]/g, ""), "neighbor");
            }
            editor.remove();
            menuElement.remove();
        }
    }
    return "Tag deletion cases passed";
};

test("tag menu deletion removes structural boundaries and preserves surrounding content", {
    skip: process.platform === "linux" && !process.env.DISPLAY && !process.env.WAYLAND_DISPLAY,
    timeout: 45000,
}, async () => {
    const compile = (text: string) => transpileModule(text, {
        compilerOptions: {target: ScriptTarget.ES2021, module: ModuleKind.CommonJS},
    }).outputText;
    const read = (name: string) => readFileSync(path.join(__dirname, "..", name + ".ts"), "utf8");
    const extract = (file: string, name: string) => {
        const source = createSourceFile(file, read(file), ScriptTarget.Latest, true);
        const declaration = source.statements.filter(isVariableStatement).flatMap(statement =>
            Array.from(statement.declarationList.declarations)).find(item => item.name.getText(source) === name);
        return compile(`const ${name} = ${declaration.initializer.getText(source)};`);
    };
    const sources = Object.fromEntries(["protyle/wysiwyg/compositionInput", "protyle/util/longTextWrap",
        "protyle/util/inlineElementBoundary", "protyle/util/inlineElementMarker"].map(name => [name, compile(read(name))]));
    const source = `const __name = value => value; (${browserCases.toString()})(${JSON.stringify(sources)}, ` +
        `${JSON.stringify(extract("menus/protyle", "tagMenu"))}, ${JSON.stringify(extract("protyle/util/selection", "focusByWbr"))})`;
    const temporary = mkdtempSync(path.join(tmpdir(), "siyuan-tag-menu-test-"));
    const script = path.join(temporary, "run.cjs");
    const lutePath = path.resolve(__dirname, "../../stage/protyle/js/lute/lute.min.js");
    writeFileSync(script, `const {app, BrowserWindow} = require("electron");
app.setPath("userData", ${JSON.stringify(path.join(temporary, "profile"))});
app.commandLine.appendSwitch("disable-gpu");
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(lutePath)}, "utf8"));
        console.log(await win.webContents.executeJavaScript(${JSON.stringify(source)}));
        win.destroy();
        app.exit(0);
    } catch (error) {
        console.error(error);
        win.destroy();
        app.exit(1);
    }
});`, "utf8");
    const env = {...process.env};
    delete env.ELECTRON_RUN_AS_NODE;
    try {
        const result = await promisify(execFile)(require("electron") as unknown as string, [script],
            {env, timeout: 40000, windowsHide: true});
        assert.match(result.stdout, /Tag deletion cases passed/);
    } finally {
        assert.equal(path.dirname(path.resolve(temporary)), path.resolve(tmpdir()));
        assert.ok(path.basename(temporary).startsWith("siyuan-tag-menu-test-"));
        rmSync(temporary, {recursive: true, force: true});
    }
});