Skip to content

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

17.4 KB
Raw Blame
import * as assert from "node:assert/strict";
import test from "node:test";
import {readFileSync} from "node:fs";
import {resolve} from "node:path";
import {
    getEntryCatalogChildren,
    getEntryCatalogCustomDefaultVisibility,
    getEntryCatalogDefaultVisibility,
    getEntryCatalogNode,
} from "./catalog";
import {TOOLBAR_ENTRY_ROOT_PATH} from "../../protyle/toolbar/defaults";
import {
    getBuiltinProfileEntryVisibility,
    getProfileEntryVisibility,
    getSavedEntryOrder,
    isEntryVisibilityImportVersionSupported,
    normalizeEntryVisibilityImportProfile,
    resetEntryProfileOrder,
} from "./profile";
import {getMobileToolbarContextPath} from "./mobileToolbarContext";
import {mergeEntryOrderPreservingUnknown, resolveEntryOrder} from "./order";

const frequentPath = "editor.slash.menu.frequent";

test("version 7 profiles preserve sparse defaults and old profiles remain independent", () => {
    for (const defaults of ["simple", "full"] as const) {
        const input: Pick<Config.IEntryVisibilityProfile, "name" | "defaults" | "entries" | "orders"> = {
            name: "Inherited", defaults, entries: {"plugin:disabled:item": false}, orders: {dock: ["plugin:disabled:dock"]},
        };
        const imported = normalizeEntryVisibilityImportProfile(input, 7, {});
        assert.deepEqual(imported, input);
        assert.deepEqual(normalizeEntryVisibilityImportProfile(JSON.parse(JSON.stringify(imported)), 7, {}), input);
        assert.equal(imported.entries[frequentPath], undefined);
        const legacy = normalizeEntryVisibilityImportProfile({...input, base: defaults}, 6, {});
        assert.equal(legacy.defaults, undefined);
        assert.equal(legacy.entries[frequentPath], true);
    }
    assert.equal(normalizeEntryVisibilityImportProfile({name: "Invalid", defaults: "unknown", entries: {}}, 7, {}), undefined);
    assert.equal(normalizeEntryVisibilityImportProfile({name: "Legacy", entries: {}}, 7, {}).defaults, undefined);
    assert.equal(isEntryVisibilityImportVersionSupported(7, 7), true);
    assert.equal(isEntryVisibilityImportVersionSupported(7, 6), false);
});

test("mobile toolbar contexts expose relevant entries and hide caret references by default", () => {
    const input = getMobileToolbarContextPath(false);
    const selection = getMobileToolbarContextPath(true);
    const inputKeys = getEntryCatalogChildren(input).map(item => item.key);
    const selectionKeys = getEntryCatalogChildren(selection).map(item => item.key);
    assert.ok(inputKeys.includes("mobile-add") && inputKeys.includes("mobile-indent") && inputKeys.includes("block-ref"));
    assert.equal(inputKeys.includes("strong"), false);
    assert.ok(selectionKeys.includes("strong") && selectionKeys.includes("block-ref"));
    assert.equal(selectionKeys.some(key => key.startsWith("mobile-")), false);
    assert.equal(selectionKeys.includes("block-type"), false);
    for (const template of ["full", "simple"] as const) {
        for (const [path, expected] of [[`${input}.block-ref`, false], [`${selection}.block-ref`, true]] as const) {
            const node = getEntryCatalogNode(path);
            assert.equal(getBuiltinProfileEntryVisibility(template, node.simple,
                getEntryCatalogDefaultVisibility(path)), expected);
        }
    }
});

test("mobile context visibility inherits legacy choices and permits independent overrides", () => {
    const input = getMobileToolbarContextPath(false);
    const selection = getMobileToolbarContextPath(true);
    const profile: {entries: Record<string, boolean>} = {entries: {"editor.toolbar.block-ref": false}};
    assert.equal(getProfileEntryVisibility(profile, `${input}.block-ref`,
        getEntryCatalogCustomDefaultVisibility(`${input}.block-ref`)), false);
    assert.equal(getProfileEntryVisibility(profile, `${selection}.block-ref`, true), false);
    profile.entries[`${selection}.block-ref`] = true;
    assert.equal(getProfileEntryVisibility(profile, `${selection}.block-ref`, false), true);
    assert.equal(getProfileEntryVisibility(profile, `${input}.block-ref`,
        getEntryCatalogCustomDefaultVisibility(`${input}.block-ref`)), false);
    assert.equal(getProfileEntryVisibility(profile, "editor.toolbar.block-ref", true), false);
    assert.equal(getProfileEntryVisibility({entries: {}}, `${input}.block-ref`,
        getEntryCatalogCustomDefaultVisibility(`${input}.block-ref`)), false);
    assert.equal(getProfileEntryVisibility({entries: {"editor.toolbar.block-ref": true}}, `${input}.block-ref`,
        getEntryCatalogCustomDefaultVisibility(`${input}.block-ref`)), false);
});

test("mobile context orders retain legacy plugin slots and reset independently", () => {
    const input = getMobileToolbarContextPath(false);
    const selection = getMobileToolbarContextPath(true);
    const legacy = ["strong", "plugin:disabled:item", "block-ref", "mobile-add", "mobile-block"];
    const profile: Pick<Config.IEntryVisibilityProfile, "orders" | "entries" | "name"> = {
        orders: {"editor.toolbar": legacy}, entries: {}, name: "Custom",
    };
    const defaults = ["mobile-add", "mobile-block", "block-ref"];
    const inherited = getSavedEntryOrder(profile, input, defaults);
    assert.deepEqual(inherited, ["plugin:disabled:item", "block-ref", "mobile-add", "mobile-block"]);
    profile.orders[input] = mergeEntryOrderPreservingUnknown(defaults, inherited,
        ["mobile-block", "mobile-add", "block-ref"]);
    assert.ok(profile.orders[input].includes("plugin:disabled:item"));
    assert.deepEqual(getSavedEntryOrder(profile, selection, ["block-ref", "strong"]),
        ["strong", "plugin:disabled:item", "block-ref"]);
    assert.deepEqual(profile.orders["editor.toolbar"], legacy);
    resetEntryProfileOrder(profile, input);
    assert.deepEqual(resolveEntryOrder(defaults, getSavedEntryOrder(profile, input, defaults), new Set()), defaults);
    assert.deepEqual(profile.orders["editor.toolbar"], legacy);
    assert.deepEqual(normalizeEntryVisibilityImportProfile(profile, 6, {}), {
        ...profile, entries: {[frequentPath]: true},
    });
});

test("chart height migration retains shared visibility and plugin order", () => {
    for (const existing of [undefined, true, false]) {
        const entries: Record<string, boolean> = {"gutter.single.chart.height": false};
        if (existing !== undefined) {
            entries["gutter.single.height"] = existing;
        }
        const profile = normalizeEntryVisibilityImportProfile({name: "Custom", entries, orders: {
            "gutter.single": ["pluginBefore", "width", "height", "pluginAfter"],
            "gutter.single.chart": ["pluginBefore", "height", "update", "pluginAfter"],
        }}, 6, {});
        assert.deepEqual(profile.entries, {"gutter.single.height": existing ?? false, [frequentPath]: true});
        assert.deepEqual(profile.orders, {
            "gutter.single": ["pluginBefore", "width", "height", "pluginAfter"],
            "gutter.single.chart": ["pluginBefore", "update", "pluginAfter"],
        });
        assert.deepEqual(normalizeEntryVisibilityImportProfile(profile, 6, {}), profile);
    }
});

test("task state imports match kernel migrations and remain stable on reimport", () => {
    const fixtures = JSON.parse(readFileSync(resolve(process.cwd(), "../kernel/conf/testdata/task_status_menu.json"), "utf8"));
    for (const fixture of fixtures) {
        const profile = normalizeEntryVisibilityImportProfile({name: "Custom", ...fixture.input}, 5, {});
        assert.deepEqual(profile, {name: "Custom", ...fixture.expected,
            entries: {...fixture.expected.entries, [frequentPath]: true}}, fixture.name);
        assert.deepEqual(normalizeEntryVisibilityImportProfile(profile, 6, {}), profile);
        assert.deepEqual(normalizeEntryVisibilityImportProfile(profile, 5, {}), profile);
    }
});

test("database submenu migration preserves visibility, order and plugin slots", () => {
    const profile = normalizeEntryVisibilityImportProfile({
        name: "Custom",
        entries: {"gutter.single.exportCSV": false, "gutter.single.showDatabaseInFolder": true},
        orders: {"gutter.single": ["pluginBefore", "separator_exportCSV", "showDatabaseInFolder", "pluginMiddle", "exportCSV", "pluginAfter"]},
    }, 4, {});
    assert.deepEqual(profile.entries, {
        "gutter.single.database.exportCSV": false,
        "gutter.single.database.showDatabaseInFolder": true,
        [frequentPath]: true,
    });
    assert.deepEqual(profile.orders, {
        "gutter.single": ["pluginBefore", "separator_exportCSV", "database", "pluginMiddle", "pluginAfter"],
        "gutter.single.database": ["showDatabaseInFolder", "exportCSV"],
    });
    assert.deepEqual(normalizeEntryVisibilityImportProfile(profile, 5, {}), profile);
});

test("font toolbar entries are visible in Full, hidden in Simple and preserve explicit profile choices", () => {
    for (const key of ["font-family", "font-size"]) {
        const path = `${TOOLBAR_ENTRY_ROOT_PATH}.${key}`;
        const defaultVisible = getEntryCatalogDefaultVisibility(path);
        const entry = getEntryCatalogNode(path);
        assert.equal(defaultVisible, true);
        assert.equal(getBuiltinProfileEntryVisibility("full", entry.simple, defaultVisible), true);
        assert.equal(getBuiltinProfileEntryVisibility("simple", entry.simple, defaultVisible), false);
        const customDefaultVisible = getEntryCatalogCustomDefaultVisibility(path);
        assert.equal(customDefaultVisible, false);
        assert.equal(getProfileEntryVisibility({entries: {}}, path, customDefaultVisible), false);
        assert.equal(getProfileEntryVisibility({entries: {[path]: true}}, path, customDefaultVisible), true);
        assert.equal(getProfileEntryVisibility({entries: {[path]: false}}, path, customDefaultVisible), false);
    }
    assert.equal(getEntryCatalogDefaultVisibility(`${TOOLBAR_ENTRY_ROOT_PATH}.text`), true);
    assert.equal(getEntryCatalogCustomDefaultVisibility(`${TOOLBAR_ENTRY_ROOT_PATH}.text`), true);
});

test("mobile font entries default to hidden and preserve explicit profile choices", () => {
    const descriptor = Object.getOwnPropertyDescriptor(globalThis, "window");
    Object.defineProperty(globalThis, "window", {configurable: true, value: {siyuan: {mobile: {}}}});
    try {
        for (const key of ["font-family", "font-size"]) {
            const path = `${TOOLBAR_ENTRY_ROOT_PATH}.${key}`;
            const defaultVisible = getEntryCatalogDefaultVisibility(path);
            const entry = getEntryCatalogNode(path);
            assert.equal(defaultVisible, false);
            assert.equal(getBuiltinProfileEntryVisibility("full", entry.simple, defaultVisible), false);
            assert.equal(getBuiltinProfileEntryVisibility("simple", entry.simple, defaultVisible), false);
            const customDefaultVisible = getEntryCatalogCustomDefaultVisibility(path);
            assert.equal(getProfileEntryVisibility({entries: {}}, path, customDefaultVisible), false);
            assert.equal(getProfileEntryVisibility({entries: {[path]: true}}, path, customDefaultVisible), true);
            assert.equal(getProfileEntryVisibility({entries: {[path]: false}}, path, customDefaultVisible), false);
        }
        assert.equal(getEntryCatalogDefaultVisibility(`${TOOLBAR_ENTRY_ROOT_PATH}.text`), true);
    } finally {
        if (descriptor) {
            Object.defineProperty(globalThis, "window", descriptor);
        } else {
            Reflect.deleteProperty(globalThis, "window");
        }
    }
});

test("built-in profiles honor entry defaults", () => {
    assert.equal(getBuiltinProfileEntryVisibility("full", false, true), true);
    assert.equal(getBuiltinProfileEntryVisibility("full", true, false), false);
    assert.equal(getBuiltinProfileEntryVisibility("simple", true, true), true);
    assert.equal(getBuiltinProfileEntryVisibility("simple", false, true), false);
    assert.equal(getBuiltinProfileEntryVisibility("simple", true, false), false);
    assert.equal(getBuiltinProfileEntryVisibility("simple", true, false, true), true);
    assert.equal(getBuiltinProfileEntryVisibility("full", true, false, true), false);
    assert.equal(getBuiltinProfileEntryVisibility("simple", true, true, false), false);
});

test("custom entry visibility preserves saved values", () => {
    const profile = {entries: {visible: true, hidden: false}};
    assert.equal(getProfileEntryVisibility(profile, "visible"), true);
    assert.equal(getProfileEntryVisibility(profile, "hidden"), false);
});

test("custom entry visibility shows missing entries", () => {
    assert.equal(getProfileEntryVisibility({entries: {}}, "new-entry"), true);
    assert.equal(getProfileEntryVisibility(undefined, "new-entry"), true);
});

test("custom entry visibility uses a caller-provided default only when the entry is missing", () => {
    const profile = {entries: {visible: true, hidden: false}};
    assert.equal(getProfileEntryVisibility(profile, "missing", false), false);
    assert.equal(getProfileEntryVisibility(profile, "visible", false), true);
    assert.equal(getProfileEntryVisibility(profile, "hidden", true), false);
});

test("entry visibility import supports versions 1 through 6", () => {
    for (const version of [1, 2, 3, 4, 5, 6]) {
        assert.equal(isEntryVisibilityImportVersionSupported(version, 6), true);
    }
    assert.equal(isEntryVisibilityImportVersionSupported(7, 6), false);
});

test("legacy entry visibility imports require base without persisting it", () => {
    const profile = normalizeEntryVisibilityImportProfile({
        name: "Legacy",
        base: "simple",
        entries: {visible: true, hidden: false, invalid: "false"},
        orders: {menu: ["known", 1, "plugin"]},
    }, 2, {});
    assert.deepEqual(profile, {
        name: "Legacy",
        entries: {visible: true, hidden: false, [frequentPath]: true},
        orders: {menu: ["known", "plugin"]},
    });
    assert.equal(normalizeEntryVisibilityImportProfile({
        name: "Legacy",
        entries: {},
    }, 2, {}), undefined);
});

test("current entry visibility imports do not require base", () => {
    const defaultOrders = {menu: ["default"]};
    assert.deepEqual(normalizeEntryVisibilityImportProfile({
        name: "Current",
        entries: {},
    }, 4, defaultOrders), {
        name: "Current",
        entries: {[frequentPath]: true},
        orders: defaultOrders,
    });
});

test("version 1 entry visibility imports use default orders", () => {
    const defaultOrders = {menu: ["default"]};
    assert.deepEqual(normalizeEntryVisibilityImportProfile({
        name: "Version 1",
        base: "full",
        entries: {},
    }, 1, defaultOrders), {
        name: "Version 1",
        entries: {[frequentPath]: true},
        orders: defaultOrders,
    });
});

test("version 3 entry visibility imports migrate the edit mode submenu", () => {
    assert.deepEqual(normalizeEntryVisibilityImportProfile({
        name: "Legacy edit mode",
        entries: {
            "document.more.editMode": true,
            "document.more.editMode.wysiwyg": false,
            "document.more.editMode.preview": false,
        },
        orders: {
            "document.more.editMode": ["preview", "wysiwyg"],
        },
    }, 3, {}), {
        name: "Legacy edit mode",
        entries: {"document.more.editMode": false, [frequentPath]: true},
        orders: {},
    });
});

test("version 3 entry visibility imports keep the merged mode entry when a legacy child is visible", () => {
    assert.deepEqual(normalizeEntryVisibilityImportProfile({
        name: "Partially visible edit mode",
        entries: {
            "document.more.editMode": true,
            "document.more.editMode.wysiwyg": false,
            "document.more.editMode.preview": true,
        },
    }, 3, {}), {
        name: "Partially visible edit mode",
        entries: {"document.more.editMode": true, [frequentPath]: true},
        orders: {},
    });
});

test("legacy profile imports materialize the frequent default across every supported version", () => {
    for (const version of [1, 2, 3, 4, 5, 6]) {
        const input = {name: "Legacy", base: "simple", entries: {"editor.slash.menu": false}};
        const profile = normalizeEntryVisibilityImportProfile(input, version, {});
        assert.equal(profile.entries[frequentPath], true);
        assert.equal(profile.entries["editor.slash.menu"], false);
        assert.equal(Object.prototype.hasOwnProperty.call(input.entries, frequentPath), false);
        const exported = JSON.parse(JSON.stringify({version: 6, profile}));
        assert.deepEqual(normalizeEntryVisibilityImportProfile(exported.profile, exported.version, {}), profile);
    }
});

test("frequent profile choices survive import and export without changing order or plugin entries", () => {
    for (const enabled of [false, true]) {
        const input = {name: "Custom", entries: {
            [frequentPath]: enabled, "editor.slash.menu.plugin:example:item": false,
        }, orders: {"editor.slash.menu": ["plugin:example:item", "template"]}};
        const profile = normalizeEntryVisibilityImportProfile(input, 6, {});
        assert.deepEqual(profile, input);
        const exported = JSON.parse(JSON.stringify({version: 6, profile}));
        assert.deepEqual(normalizeEntryVisibilityImportProfile(exported.profile, exported.version, {}), input);
    }
});

test("invalid imported frequent values use the explicit default", () => {
    for (const invalid of [null, "false", 0, {}, []]) {
        const profile = normalizeEntryVisibilityImportProfile({
            name: "Custom", entries: {[frequentPath]: invalid},
        }, 6, {});
        assert.deepEqual(profile.entries, {[frequentPath]: true});
    }
});