Skip to content

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

14.3 KB
Raw Blame
import * as assert from "node:assert/strict";
import {readFileSync} from "node:fs";
import test from "node:test";
import {runInNewContext} from "node:vm";
import {createSourceFile, isClassDeclaration, isPropertyAssignment, ScriptTarget, transpileModule} from "typescript";
import {getListMindmapConnectorMenuItem} from "./connectorMenu";
import {getListMindmapFoldMenuItems} from "./foldMenu";
import {assignListMindmapBranchColors, getListMindmapAppearanceMenu} from "./appearance";

const source = createSourceFile("index.ts", readFileSync("src/protyle/render/listMindmap/index.ts", "utf8"),
    ScriptTarget.ES2021, true);
const controller = source.statements.find(item => isClassDeclaration(item) && item.name?.text === "ListMindmapController");
assert.ok(controller && isClassDeclaration(controller));
let callback = "";
let batchCallback = "";
const visit = (node: import("typescript").Node) => {
    if (isPropertyAssignment(node) && node.name.getText(source) === "onSettingsMenu") {
        callback = node.initializer.getText(source);
    }
    if (isPropertyAssignment(node) && node.name.getText(source) === "onNodesStyle") {
        batchCallback = node.initializer.getText(source);
    }
    node.forEachChild(visit);
};
visit(controller);
assert.ok(callback);
assert.ok(batchCallback);
const methods = controller.members.filter(item => item.name && ["metadata", "change"].includes(item.name.getText(source)));
const compiled = transpileModule(`class Controller {
    ${methods.map(item => item.getText(source)).join("\n")}
    onSettingsMenu = ${callback};
    onNodesStyle = ${batchCallback};
}
globalThis.Controller = Controller;`, {compilerOptions: {target: ScriptTarget.ES2021}}).outputText;

test("desktop and mobile settings cancel theme previews and persist one undoable change with existing metadata", async () => {
    for (const mobile of [false, true]) {
        let data = {version: 2, nodes: {child: {lineColor: "red"}}, relations: [] as unknown[], extension: "keep"};
        const original = JSON.stringify(data);
        const list = {isConnected: true, dataset: {nodeId: "map"}, closest: (): null => null,
            get outerHTML() { return JSON.stringify(data); }};
        const transactions: {before: string, after: string}[] = [];
        let editable = true;
        let item: IMenu;
        let appearanceItem: IMenu;
        let defaultItem: IMenu;
        let expandItem: IMenu;
        let panItem: IMenu;
        let entries: IMenu[];
        let closeMenu: () => void;
        const rendered: import("./model").ListMindmapModel[] = [];
        const menuWindow = Object.assign(new EventTarget(), {
            siyuan: {languages: {listMindmapExpandToLevel: "Level ${level}"}},
        });
        const dismiss = () => {
            const close = closeMenu;
            closeMenu = undefined;
            close?.();
        };
        let defaultStyle = "bezier";
        const defaults: string[] = [];
        const placements: unknown[] = [];
        const anchor = {getBoundingClientRect: () => ({left: 20, bottom: 100, height: 24})};
        const context: any = {
            owner: {}, list,
            canEdit: () => editable,
            getListMindmapConnectorMenuItem,
            getListMindmapAppearanceMenu,
            assignListMindmapBranchColors,
            getListMindmapFoldMenuItems,
            getDefaultListMindmapConnectorStyle: () => defaultStyle,
            setDefaultListMindmapConnectorStyle: (style: string) => { defaultStyle = style; defaults.push(style); },
            getListMindmapSiblingIDs: () => new Map(),
            normalizeListMindmapSummaryMetadata: () => {},
            readListMindmap: () => ({root: {id: "root", children: [{id: "child"}]}, metadata: JSON.parse(JSON.stringify(data)),
                nodes: new Map([["root", {children: []}], ["child", {children: []}]])}),
            writeListMindmapMetadata: (_list: unknown, value: typeof data) => data = value,
            cleanListMindmapHTML: (html: string) => html,
            updateTransaction: (_owner: unknown, _list: unknown, before: string) =>
                transactions.push({before, after: list.outerHTML}),
            showMessage: () => assert.fail("valid connector changes must not report an error"),
            isMobile: () => mobile,
            toggleMenu: ({target, build}: {target: unknown, build: (menu: unknown, session: unknown) => void}) => {
                assert.equal(target, anchor);
                dismiss();
                build(undefined, {show: (open: () => void) => open()});
            },
            Menu: class {
                constructor(_id?: string, close?: () => void) { entries = []; closeMenu = close; }
                addItem(value: IMenu) {
                    entries.push(value);
                    if (value.id === "defaultConnectorStyle") { defaultItem = value; }
                    else if (value.id === "expandLevel") { expandItem = value; }
                    else if (value.id === "pan") { panItem = value; }
                    else if (value.id === "appearance") {
                        appearanceItem = value;
                        item = (value.submenu as IMenu[]).find(entry => entry.id === "connectorStyle");
                    }
                }
                open(position: unknown) { placements.push(position); }
                fullscreen(position: unknown) { placements.push(position); }
            },
            window: menuWindow, console,
        };
        runInNewContext(compiled, context);
        const target = new context.Controller();
        Object.assign(target, {list, owner: {}, model: context.readListMindmap(),
            view: {getSelectedId: () => "root", update: (model: import("./model").ListMindmapModel) => rendered.push(model)},
            refresh: () => target.model = context.readListMindmap()});
        const choose = (style: string) => (item.submenu as IMenu[]).find(entry => entry.id === style).click(undefined, undefined);
        target.onSettingsMenu(anchor);
        assert.equal((item.submenu as IMenu[]).find(entry => entry.checked).id, "bezier");
        assert.deepEqual(JSON.parse(JSON.stringify(placements)), [mobile ? "bottom" : {x: 20, y: 100, h: 24}]);
        assert.equal(expandItem, undefined, "wide views keep expansion in the direct toolbar");
        let selectedLevel: unknown;
        target.onSettingsMenu(anchor, (level: unknown) => selectedLevel = level);
        assert.deepEqual((expandItem.submenu as IMenu[]).map(entry => entry.id),
            ["expandAll", "foldAll", "separator_all", "level1", "level2", "level3", "level4", "level5", "level6"]);
        (expandItem.submenu as IMenu[]).find(entry => entry.id === "level3").click(undefined, undefined);
        assert.equal(selectedLevel, 3, "narrow desktop and mobile views retain global expansion in More");
        (defaultItem.submenu as IMenu[]).find(entry => entry.id === "rounded").click(undefined, undefined);
        assert.deepEqual(defaults, ["rounded"]);
        assert.equal(transactions.length, 0, "changing the preference must not enter document undo history");
        assert.equal(JSON.stringify(data), original, "changing the preference must not restyle the current map");
        target.onSettingsMenu(anchor);
        assert.equal((defaultItem.submenu as IMenu[]).find(entry => entry.checked).id, "rounded");
        assert.equal((item.submenu as IMenu[]).find(entry => entry.checked).id, "bezier");
        choose("orthogonal");
        assert.equal(transactions.length, 1);
        assert.equal(transactions[0].before, original);
        assert.deepEqual(JSON.parse(transactions[0].after), {...JSON.parse(original), connectorStyle: "orthogonal"});
        const saved = transactions[0].after;
        data = JSON.parse(transactions[0].before);
        target.onSettingsMenu(anchor);
        assert.equal((item.submenu as IMenu[]).find(entry => entry.checked).id, "bezier", "undo restores the missing default");
        data = JSON.parse(saved);
        target.onSettingsMenu(anchor);
        assert.equal((item.submenu as IMenu[]).find(entry => entry.checked).id, "orthogonal", "redo restores the saved preset");
        choose("orthogonal");
        assert.equal(transactions.length, 1, "choosing the current style is a no-op");
        let finish: (value: boolean) => void;
        target.activeEditor = {finish: () => new Promise<boolean>(resolve => finish = resolve)};
        choose("rounded");
        data.extension = "remote edit";
        finish(true);
        await new Promise(resolve => setImmediate(resolve));
        assert.equal(JSON.parse(transactions[1].after).extension, "remote edit", "pending text edits cannot overwrite newer metadata");
        target.activeEditor = undefined;
        choose("bezier");
        assert.equal(Object.hasOwn(data, "connectorStyle"), false, "restoring the default removes the optional field");
        target.onSettingsMenu(anchor);
        const theme = (appearanceItem.submenu as IMenu[]).find(entry => entry.id === "theme");
        const beforeTheme = list.outerHTML;
        const beforeCount = transactions.length;
        const waves = (theme.submenu as IMenu[]).find(entry => entry.id === "waves");
        let applyTheme = waves;
        const swatch = new EventTarget();
        waves.bind?.(swatch as unknown as HTMLElement);
        const enter = (pointerType: string) => swatch.dispatchEvent(Object.assign(new Event("pointerenter"), {pointerType}));
        const beforeRenderCount = rendered.length;
        enter("touch");
        assert.equal(rendered.length, beforeRenderCount, "touch does not preview or select a theme");
        enter("mouse");
        if (mobile) {
            assert.equal(waves.bind, undefined, "mobile themes retain tap-to-apply behavior");
        } else {
            assert.equal(rendered.at(-1).metadata.appearance.rootColor, "#849695", "hover previews the theme immediately");
            assert.notEqual(rendered.at(-1).metadata, target.model.metadata, "preview uses a separate metadata snapshot");
            assert.equal(rendered.at(-1).metadata.nodes.child.lineColor, "red", "preview preserves manual colors");
            assert.equal(target.model.metadata.appearance, undefined, "hover leaves the controller's canonical model unchanged");
            swatch.dispatchEvent(new Event("pointerleave"));
            assert.equal(rendered.at(-1), target.model, "leaving the row restores the saved model");
            enter("mouse");
            menuWindow.dispatchEvent(Object.assign(new Event("keydown"), {key: "Escape"}));
            assert.equal(rendered.at(-1), target.model, "Escape cancels preview even when only a submenu closes");
            enter("mouse");
            dismiss();
            assert.equal(rendered.at(-1), target.model, "dismissing the menu restores the latest saved model");
            const closedRenderCount = rendered.length;
            enter("mouse");
            assert.equal(rendered.length, closedRenderCount, "a closed menu cannot reapply an obsolete preview");
            target.onSettingsMenu(anchor);
            applyTheme = ((appearanceItem.submenu as IMenu[]).find(entry => entry.id === "theme").submenu as IMenu[])
                .find(entry => entry.id === "waves");
            const activeSwatch = new EventTarget();
            applyTheme.bind(activeSwatch as unknown as HTMLElement);
            activeSwatch.dispatchEvent(Object.assign(new Event("pointerenter"), {pointerType: "mouse"}));
        }
        assert.equal(list.outerHTML, beforeTheme, "preview never changes source attributes or content");
        assert.equal(transactions.length, beforeCount, "preview never creates undo entries");
        applyTheme.click(undefined, undefined);
        dismiss();
        if (!mobile) {
            assert.equal(rendered.at(-1), target.model, "closing after applying retains the newly saved model");
        }
        assert.equal(transactions.length, beforeCount + 1, "applying a palette is one document transaction on both platforms");
        assert.equal(transactions.at(-1).before, beforeTheme);
        assert.equal(JSON.parse(list.outerHTML).nodes.child.lineColor, "red", "theme changes retain manual overrides");
        assert.equal(JSON.parse(list.outerHTML).nodes.child.branchColor, 0, "branch slots are saved with the same snapshot");
        assert.equal(JSON.parse(list.outerHTML).appearance.rootColor, "#849695",
            "the root theme color is saved in the same document transaction on desktop and mobile");
        assert.equal(JSON.parse(list.outerHTML).appearance.nodeStyle, "branch",
            "the reference style is saved with the root and branch palette on both platforms");
        const themed = list.outerHTML;
        data = JSON.parse(beforeTheme);
        assert.equal(JSON.parse(list.outerHTML).appearance, undefined, "undo restores the unthemed document");
        data = JSON.parse(themed);
        target.onNodesStyle(["root", "child", "deleted"], {backgroundColor: "#fed7aa", textColor: "#000000"});
        assert.equal(transactions.length, beforeCount + 2, "batch node colors save one snapshot");
        const updated = JSON.parse(list.outerHTML);
        assert.equal(updated.nodes.root.backgroundColor, "#fed7aa");
        assert.equal(updated.nodes.child.backgroundColor, "#fed7aa");
        assert.equal(updated.nodes.child.lineColor, "red");
        assert.equal(updated.nodes.deleted, undefined, "a stale selection cannot create orphan styles");
        const count = transactions.length;
        editable = false;
        choose("spline");
        (theme.submenu as IMenu[]).find(entry => entry.id === "dream").click(undefined, undefined);
        target.onNodesStyle(["root", "child"], {backgroundColor: "#ffffff"});
        (defaultItem.submenu as IMenu[]).find(entry => entry.id === "spline").click(undefined, undefined);
        assert.deepEqual(defaults, ["rounded"], "a stale menu cannot change preferences after editing is disabled");
        assert.equal(transactions.length, count, "an already open menu cannot edit a newly read-only map");
        let panToggles = 0;
        target.onSettingsMenu(anchor, undefined, {active: true, toggle: () => panToggles++});
        assert.deepEqual(entries.map(entry => entry.id), ["pan"], "read-only menus contain no editable global settings");
        assert.equal(panItem.checked, true, "the fallback pan mode remains visible in a read-only map's More menu");
        panItem.click(undefined, undefined);
        assert.equal(panToggles, 1);
        assert.equal(transactions.length, count, "switching pan mode never changes source data");
    }
});