Skip to content

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

7.4 KB
Raw Blame
import * as assert from "node:assert/strict";
import test from "node:test";
import {
    DESKTOP_TOOLBAR_ENTRIES,
    getDefaultToolbar,
    getPluginToolbarEntryKey,
    getToolbarEntryId,
    getToolbarEntryLabel,
    markPluginToolbarEntries,
} from "./defaults";
import {normalizeToolbarSeparators, resolveToolbarItems} from "./entryVisibility";
import {mergeEntryOrderPreservingUnknown, moveEntryOrder} from "../../config/entryVisibility/order";

interface IToolbarTestItem {
    key?: string;
    separator?: boolean;
}

test("mobile toolbar shares desktop identifiers and declaration order", () => {
    const mobile = getDefaultToolbar(true).map(item => typeof item === "string" ? {name: item} : item);
    assert.deepEqual(mobile.map(getToolbarEntryId),
        DESKTOP_TOOLBAR_ENTRIES.filter(item => item.name !== "format-painter").map(item => item.key));
});

test("block type enters old orders without disturbing hidden entries or plugin slots", () => {
    const defaults = DESKTOP_TOOLBAR_ENTRIES.map(item => item.key);
    const saved = defaults.filter(key => key !== "block-type");
    saved.splice(saved.indexOf("strong"), 0, "plugin:missing:action");
    const merged = mergeEntryOrderPreservingUnknown(defaults, saved);
    assert.equal(merged.filter(key => key === "block-type").length, 1);
    assert.equal(merged.indexOf("plugin:missing:action"), saved.indexOf("plugin:missing:action"));
    assert.deepEqual(merged.filter(key => !["block-type", "plugin:missing:action"].includes(key)),
        saved.filter(key => key !== "plugin:missing:action"));
    const items = defaults.map(key => ({key, separator: key.startsWith("separator_")}));
    const hidden = resolve(items, {order: merged, hidden: ["block-type", "a"]});
    assert.equal(hidden.visible.some(item => item.key === "block-type" || item.key === "a"), false);
    assert.equal(hidden.visible[0].separator, false);
    assert.equal(hidden.visible[hidden.visible.length - 1].separator, false);
});

test("font entries merge into old profiles while preserving plugin slots and hidden entries", () => {
    const defaults = DESKTOP_TOOLBAR_ENTRIES.map(item => item.key);
    const separators = new Set(DESKTOP_TOOLBAR_ENTRIES.filter(item => item.separator).map(item => item.key));
    const saved = defaults.filter(key => !["font-family", "font-size"].includes(key));
    saved.splice(saved.indexOf("strong"), 0, "plugin:unloaded:action");
    const merged = mergeEntryOrderPreservingUnknown(defaults, saved, undefined, separators);
    assert.ok(merged.includes("plugin:unloaded:action"));
    assert.equal(merged.indexOf("plugin:unloaded:action"), saved.indexOf("plugin:unloaded:action"));
    assert.deepEqual(merged.filter(key => !["font-family", "font-size", "plugin:unloaded:action"].includes(key)),
        saved.filter(key => key !== "plugin:unloaded:action"));
    const items = defaults.map(key => ({key, separator: separators.has(key)}));
    const result = resolve(items, {order: merged, hidden: ["text", "font-family"]});
    assert.equal(result.visible.some(item => item.key === "text" || item.key === "font-family"), false);
    assert.equal(result.visible.some(item => item.key === "font-size"), true);
    const moved = moveEntryOrder(defaults, "font-size", "font-family", false, separators);
    const updated = mergeEntryOrderPreservingUnknown(defaults, merged, moved, separators);
    assert.ok(updated.includes("plugin:unloaded:action"));
    assert.ok(updated.indexOf("font-size") < updated.indexOf("font-family"));
});

const resolve = (items: IToolbarTestItem[], options: {
    hidden?: string[];
    order?: string[];
} = {}) => resolveToolbarItems(items, {
    getKey: (item) => item.key,
    isSeparator: (item) => item.separator === true,
    isVisible: (key) => !(options.hidden || []).includes(key),
    order: options.order || items.flatMap((item): string | [] => item.key || []),
});

test("desktop toolbar defaults expose stable configuration identifiers", () => {
    const entries = getDefaultToolbar(false).map((item) => typeof item === "string" ? {name: item} : item);
    assert.deepEqual(entries.map(getToolbarEntryId), DESKTOP_TOOLBAR_ENTRIES.map((item) => item.key));
    assert.equal(getToolbarEntryId({name: "plugin-item"}), undefined);
});

test("plugin toolbar entries use plugin-scoped configuration identifiers", () => {
    const existing = {name: "existing"};
    const pluginItem = {name: "shared.item"};
    const marked = markPluginToolbarEntries([existing], [existing, pluginItem, "|"], "plugin.name",
        (item) => `Plugin - ${item.name}`) as IMenuItem[];
    assert.equal(getToolbarEntryId(existing), undefined);
    assert.equal(getToolbarEntryId(marked[1]), getPluginToolbarEntryKey("plugin.name", "shared.item"));
    assert.equal(getToolbarEntryLabel(marked[1]), "Plugin - shared.item");
    assert.equal(getToolbarEntryId(Object.assign({}, marked[1])),
        getPluginToolbarEntryKey("plugin.name", "shared.item"));
    assert.equal(getToolbarEntryId(marked[2]), getPluginToolbarEntryKey("plugin.name", "1", "separator"));
    assert.notEqual(getPluginToolbarEntryKey("plugin.name", "shared.item"),
        getPluginToolbarEntryKey("another.plugin", "shared.item"));
    assert.notEqual(getPluginToolbarEntryKey("plugin.name", "shared.item"),
        getPluginToolbarEntryKey("plugin", "name.shared.item"));
});

test("toolbar applies configured order while preserving unregistered slots", () => {
    const unregistered = {};
    const result = resolve([{key: "a"}, unregistered, {key: "b"}, {key: "c"}], {
        order: ["c", "b", "a"],
    });
    assert.deepEqual(result.ordered, [{key: "c"}, unregistered, {key: "b"}, {key: "a"}]);
});

test("toolbar restores a temporarily removed plugin entry to its configured slot", () => {
    const pluginKey = getPluginToolbarEntryKey("plugin.name", "item");
    const order = ["a", pluginKey, "b"];
    assert.deepEqual(resolve([{key: "a"}, {key: "b"}], {order}).ordered, [{key: "a"}, {key: "b"}]);
    assert.deepEqual(resolve([{key: "a"}, {key: "b"}, {key: pluginKey}], {order}).ordered, [
        {key: "a"},
        {key: pluginKey},
        {key: "b"},
    ]);
});

test("toolbar hides configured entries without hiding unregistered entries", () => {
    const unregistered = {};
    const result = resolve([{key: "a"}, unregistered, {key: "b"}], {hidden: ["a", "b"]});
    assert.deepEqual(result.visible, [unregistered]);
});

test("toolbar hides a configured plugin entry without hiding unregistered entries", () => {
    const pluginKey = getPluginToolbarEntryKey("plugin.name", "item");
    const unregistered = {};
    const result = resolve([{key: pluginKey}, unregistered], {hidden: [pluginKey]});
    assert.deepEqual(result.visible, [unregistered]);
});

test("toolbar removes empty groups after visibility filtering", () => {
    const result = resolve([
        {key: "separator_1", separator: true},
        {key: "a"},
        {key: "separator_2", separator: true},
        {key: "separator_3", separator: true},
        {key: "b"},
        {key: "separator_4", separator: true},
    ], {hidden: ["a"]});
    assert.deepEqual(result.visible, [{key: "b"}]);
});

test("toolbar separator normalization removes leading, trailing, and consecutive separators", () => {
    const items = [
        {separator: true},
        {key: "a"},
        {separator: true},
        {separator: true},
        {key: "b"},
        {separator: true},
    ];
    assert.deepEqual(normalizeToolbarSeparators(items, (item) => item.separator === true), [
        {key: "a"},
        {separator: true},
        {key: "b"},
    ]);
});