Skip to content

Build your personal knowledge base with Trilium Notes

23.5 KB
Raw Blame
import {
    _getModelData as getModelData,
    _setModelData as setModelData,
    BlockToolbar,
    ClassicEditor,
    ContextualBalloon,
    DropdownView,
    Essentials,
    IconTable,
    keyCodes,
    Paragraph,
    Table,
    TableUtils
} from "ckeditor5";
import editorStylesheetUrl from "ckeditor5/ckeditor5.css?url";
import type { ModelElement } from "ckeditor5";
import { beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
import { userEvent } from "vitest/browser";

import { createTestEditor } from "../../../test/editor-kit.js";
import TableInsertFormView, {
    DEFAULT_TABLE_SIZE,
    MAX_TABLE_CELLS,
    MAX_TABLE_COLUMNS
} from "./table_insert_form.js";
import TableInsertUI from "./table_insert_ui.js";

describe("TableInsertUI", () => {
    let editor: ClassicEditor;
    let balloon: ContextualBalloon;

    // The grid, the dropdown panel and the balloon need the editor's stylesheet to have a layout.
    beforeAll(() => new Promise<void>((resolve, reject) => {
        const link = document.createElement("link");
        link.rel = "stylesheet";
        link.href = editorStylesheetUrl;
        link.onload = () => resolve();
        link.onerror = () => reject(new Error("the editor stylesheet did not load"));
        document.head.appendChild(link);
    }));

    beforeEach(async () => {
        editor = await createTestEditor([Essentials, Paragraph, Table, TableInsertUI], {
            toolbar: ["insertTable"]
        });
        balloon = editor.plugins.get(ContextualBalloon);
        setModelData(editor.model, "<paragraph>foo[]</paragraph>");
        editor.editing.view.focus();
    });

    describe("dropdown", () => {
        it("keeps the button of the upstream dropdown", () => {
            expect(getToolbarDropdown(editor).buttonView).toMatchObject({
                label: "Insert table",
                icon: IconTable,
                tooltip: true
            });
        });

        it("is enabled with the insertTable command", () => {
            const dropdown = getToolbarDropdown(editor);
            expect(dropdown.isEnabled).toBe(true);

            editor.enableReadOnlyMode("spec");
            expect(dropdown.isEnabled).toBe(false);

            editor.disableReadOnlyMode("spec");
            expect(dropdown.isEnabled).toBe(true);
        });

        it("shows the Insert table… button, a separator and the size grid", async () => {
            const dropdown = getToolbarDropdown(editor);
            expect(dropdown.panelView.children.length).toBe(0);

            await openDropdown(dropdown);

            const panel = getElement(dropdown.panelView);
            const button = getFormButton(dropdown);
            const separator = panel.querySelector(".ck-list__separator");
            const grid = panel.querySelector(".ck-insert-table-dropdown__grid");
            expect(button.textContent).toBe("Insert table…");
            expect(button.classList.contains("ck-button_with-text")).toBe(true);
            expect(button.parentElement?.classList.contains("ck-list__item")).toBe(true);
            expect(button.compareDocumentPosition(separator as Node))
                .toBe(Node.DOCUMENT_POSITION_FOLLOWING);
            expect(separator?.compareDocumentPosition(grid as Node))
                .toBe(Node.DOCUMENT_POSITION_FOLLOWING);

            // The grid keeps the size label of the upstream dropdown.
            expect(panel.querySelector(".ck-insert-table-dropdown__label")?.textContent)
                .toBe("1 × 1");

            // The panel is built once, not on every opening.
            dropdown.isOpen = false;
            dropdown.isOpen = true;
            expect(dropdown.panelView.children.length).toBe(1);
            expect(panel.querySelectorAll(".ck-list__item")).toHaveLength(1);
        });

        it("inserts the table picked in the grid", async () => {
            const dropdown = getToolbarDropdown(editor);
            await openDropdown(dropdown);

            const box = getElement(dropdown.panelView)
                .querySelector<HTMLElement>("[data-row=\"3\"][data-column=\"4\"]");
            if (!box) {
                throw new Error("The grid has no 3 × 4 box.");
            }
            await userEvent.hover(box);
            await userEvent.click(box);

            expect(getTableSize(editor)).toEqual({ rows: 3, columns: 4 });
            expect(dropdown.isOpen).toBe(false);
            expect(balloon.visibleView).toBeNull();
            expect(editor.editing.view.document.isFocused).toBe(true);
        });

        it("moves the focus between the grid and the button with Tab", async () => {
            const dropdown = getToolbarDropdown(editor);
            // Keeps the pointer off the grid, whose boxes take the focus on hover.
            await userEvent.hover(getElement(dropdown.buttonView));
            getElement(dropdown.buttonView).focus();

            await userEvent.keyboard("{ArrowDown}");
            expect(dropdown.isOpen).toBe(true);
            const firstBox = getElement(dropdown.panelView)
                .querySelector(".ck-insert-table-dropdown-grid-box");
            expect(document.activeElement).toBe(firstBox);

            await userEvent.keyboard("{Tab}");
            expect(document.activeElement).toBe(getFormButton(dropdown));
            await userEvent.keyboard("{Tab}");
            expect(document.activeElement).toBe(firstBox);
            await userEvent.keyboard("{Shift>}{Tab}{/Shift}");
            expect(document.activeElement).toBe(getFormButton(dropdown));

            await userEvent.keyboard("{Enter}");
            expect(dropdown.isOpen).toBe(false);
            expect(document.activeElement)
                .toBe(getForm(balloon).columnsField.inputView.element);
        });
    });

    describe("form", () => {
        it("opens at the caret when Insert table… is clicked", async () => {
            const dropdown = getToolbarDropdown(editor);
            await openDropdown(dropdown);

            await userEvent.click(getFormButton(dropdown));

            expect(dropdown.isOpen).toBe(false);
            const form = getForm(balloon);
            expect(getInput(form, "rows").value).toBe(String(DEFAULT_TABLE_SIZE));
            expect(getInput(form, "columns").value).toBe(String(DEFAULT_TABLE_SIZE));
            expect(document.activeElement).toBe(getInput(form, "columns"));

            // The balloon points at the caret, after "foo".
            const caret = getCaretRect(editor);
            const panel = getElement(balloon.view).getBoundingClientRect();
            expect(balloon.view.isVisible).toBe(true);
            expect(caret.left).toBeGreaterThanOrEqual(panel.left);
            expect(caret.left).toBeLessThanOrEqual(panel.right);
            const gap = Math.min(
                Math.abs(panel.top - caret.bottom),
                Math.abs(caret.top - panel.bottom)
            );
            expect(gap).toBeLessThan(30);
        });

        it("is at least 350px wide, with segments spanning it", async () => {
            const form = await openForm(editor);
            form.useHeaders = true;

            const formElement = getElement(form);
            const formRect = formElement.getBoundingClientRect();
            const formStyle = getComputedStyle(formElement);
            const contentLeft = formRect.left + parseFloat(formStyle.paddingLeft);
            const contentRight = formRect.right - parseFloat(formStyle.paddingRight);
            expect(formRect.width).toBeGreaterThanOrEqual(350);
            expect(getElement(form.insertButtonView).getBoundingClientRect().right)
                .toBeCloseTo(contentRight, 0);

            const segments = Array.from(formElement
                .querySelectorAll<HTMLElement>(".ck-table-insert-form__segment"));
            expect(segments).toHaveLength(5);
            for (const segment of segments) {
                const rect = segment.getBoundingClientRect();
                expect(rect.left).toBeCloseTo(contentLeft, 0);
                expect(rect.right).toBeCloseTo(contentRight, 0);
            }

            const segmentStyle = getComputedStyle(segments[0]);
            const innerLeft = contentLeft + parseFloat(segmentStyle.borderLeftWidth)
                + parseFloat(segmentStyle.paddingLeft);
            const innerRight = contentRight - parseFloat(segmentStyle.borderRightWidth)
                - parseFloat(segmentStyle.paddingRight);
            for (const field of ["columns", "rows", "headingColumns", "headingRows"] as const) {
                const input = getInput(form, field);
                const rect = input.getBoundingClientRect();
                const fontSize = parseFloat(getComputedStyle(input).fontSize);
                const iconRect = getElement(form[`${field}Field`].iconView).getBoundingClientRect();
                expect(rect.width, field).toBeCloseTo(5 * fontSize, 0);
                expect(rect.right, field).toBeCloseTo(innerRight, 0);
                expect(iconRect.left, field).toBeCloseTo(innerLeft, 0);
            }

            // The switch fills its segment: the label starts at the icons, the toggle ends at
            // the inputs.
            const toggleElement = getElement(form.headersSwitchView);
            const switchLabel = toggleElement.querySelector(".ck-button__label");
            const toggle = toggleElement.querySelector(".ck-button__toggle");
            expect(switchLabel?.getBoundingClientRect().left).toBeCloseTo(innerLeft, 0);
            expect(toggle?.getBoundingClientRect().right).toBeCloseTo(innerRight, 0);
        });

        it("inserts a table of the typed size and closes", async () => {
            const form = await openForm(editor);

            await userEvent.fill(getInput(form, "rows"), "5");
            await userEvent.fill(getInput(form, "columns"), "7");
            await userEvent.click(getElement(form.insertButtonView));

            expect(getTableSize(editor)).toEqual({ rows: 5, columns: 7 });
            expect(getTableHeadings(editor)).toEqual({ rows: 0, columns: 0 });
            expect(balloon.hasView(form)).toBe(false);
            expect(editor.editing.view.document.isFocused).toBe(true);
            expect(editor.model.document.selection.getFirstPosition()?.findAncestor("tableCell"))
                .not.toBeNull();

            // One undo step removes the table.
            editor.execute("undo");
            expect(getModelData(editor.model, { withoutSelection: true }))
                .toBe("<paragraph>foo</paragraph>");
        });

        it("inserts a table with the typed header rows and columns", async () => {
            const form = await openForm(editor);

            await userEvent.fill(getInput(form, "rows"), "5");
            await userEvent.fill(getInput(form, "columns"), "4");
            await userEvent.click(getElement(form.headersSwitchView));
            await userEvent.fill(getInput(form, "headingColumns"), "1");
            await userEvent.fill(getInput(form, "headingRows"), "2");
            await userEvent.click(getElement(form.insertButtonView));

            expect(getTableSize(editor)).toEqual({ rows: 5, columns: 4 });
            expect(getTableHeadings(editor)).toEqual({ rows: 2, columns: 1 });
            expect(balloon.hasView(form)).toBe(false);
        });

        it("keeps the form open while there are more header rows than rows", async () => {
            const form = await openForm(editor);

            await userEvent.click(getElement(form.headersSwitchView));
            await userEvent.fill(getInput(form, "headingRows"), "3");
            await userEvent.keyboard("{Enter}");

            expect(getTableSize(editor)).toBeNull();
            expect(balloon.visibleView).toBe(form);
            expect(form.headingRowsField.errorText)
                .toBe(`Enter a whole number between 0 and ${DEFAULT_TABLE_SIZE}.`);

            await userEvent.fill(getInput(form, "rows"), "3");
            await userEvent.keyboard("{Enter}");
            expect(getTableSize(editor)).toEqual({ rows: 3, columns: DEFAULT_TABLE_SIZE });
            expect(getTableHeadings(editor)).toEqual({ rows: 3, columns: 0 });
        });

        it("inserts the table on Enter", async () => {
            const form = await openForm(editor);

            await userEvent.fill(getInput(form, "columns"), "3");
            await userEvent.keyboard("{Enter}");

            expect(getTableSize(editor)).toEqual({ rows: DEFAULT_TABLE_SIZE, columns: 3 });
            expect(balloon.hasView(form)).toBe(false);
        });

        it("stays open and reports invalid values", async () => {
            const form = await openForm(editor);

            await userEvent.fill(getInput(form, "rows"), "0");
            await userEvent.fill(getInput(form, "columns"), String(MAX_TABLE_COLUMNS + 1));
            await userEvent.keyboard("{Enter}");

            expect(getTableSize(editor)).toBeNull();
            expect(balloon.visibleView).toBe(form);
            expect(form.rowsField.errorText).not.toBeNull();
            expect(form.columnsField.errorText).not.toBeNull();
            expect(document.activeElement).toBe(getInput(form, "columns"));

            await userEvent.fill(getInput(form, "columns"), "4");
            await userEvent.keyboard("{Enter}");
            expect(getTableSize(editor)).toBeNull();
            expect(document.activeElement).toBe(getInput(form, "rows"));

            await userEvent.fill(getInput(form, "rows"), "3");
            await userEvent.keyboard("{Enter}");
            expect(getTableSize(editor)).toEqual({ rows: 3, columns: 4 });
        });

        it("reports a table with too many cells and inserts nothing", async () => {
            const form = await openForm(editor);

            await userEvent.fill(getInput(form, "rows"), "1000");
            await userEvent.fill(getInput(form, "columns"), "6");
            await userEvent.keyboard("{Enter}");

            const message = getElement(form)
                .querySelector<HTMLElement>(".ck-table-insert-form__size-error");
            expect(getTableSize(editor)).toBeNull();
            expect(balloon.visibleView).toBe(form);
            expect(message?.textContent)
                .toBe(`The table is too large (max ${MAX_TABLE_CELLS} cells).`);
            expect(message?.checkVisibility()).toBe(true);
            expect(document.activeElement).toBe(getInput(form, "columns"));

            await userEvent.fill(getInput(form, "rows"), "100");
            expect(message?.checkVisibility()).toBe(false);

            await userEvent.keyboard("{Enter}");
            expect(getTableSize(editor)).toEqual({ rows: 100, columns: 6 });
            expect(balloon.hasView(form)).toBe(false);
        });

        it("closes on Esc without inserting", async () => {
            const form = await openForm(editor);
            await userEvent.fill(getInput(form, "rows"), "4");

            await userEvent.keyboard("{Escape}");

            expect(balloon.hasView(form)).toBe(false);
            expect(getTableSize(editor)).toBeNull();
            expect(editor.editing.view.document.isFocused).toBe(true);

            // Closing a closed form does nothing.
            expect(() => form.keystrokes.press(createEscEvent())).not.toThrow();
            expect(balloon.visibleView).toBeNull();
        });

        it("closes on a click outside without inserting", async () => {
            const form = await openForm(editor);

            document.body.dispatchEvent(new MouseEvent("mousedown", { bubbles: true }));

            expect(balloon.hasView(form)).toBe(false);
            expect(getTableSize(editor)).toBeNull();
        });

        it("stays open on a click inside", async () => {
            const form = await openForm(editor);

            await userEvent.click(getInput(form, "columns"));

            expect(balloon.visibleView).toBe(form);
        });

        it("opens with the default size and without headers every time", async () => {
            let form = await openForm(editor);
            await userEvent.click(getElement(form.headersSwitchView));
            await userEvent.fill(getInput(form, "rows"), "0");
            await userEvent.keyboard("{Enter}");
            await userEvent.keyboard("{Escape}");

            form = await openForm(editor);

            expect(getInput(form, "rows").value).toBe(String(DEFAULT_TABLE_SIZE));
            expect(form.rowsField.errorText).toBeNull();
            expect(form.useHeaders).toBe(false);
        });

        it("showForm() leaves an open form alone", async () => {
            const form = await openForm(editor);
            await userEvent.fill(getInput(form, "rows"), "9");
            const add = vi.spyOn(balloon, "add");

            editor.plugins.get(TableInsertUI).showForm();

            expect(add).not.toHaveBeenCalled();
            expect(getInput(form, "rows").value).toBe("9");
        });

        it("does not insert while the insertTable command is disabled", async () => {
            const form = await openForm(editor);

            editor.enableReadOnlyMode("spec");
            expect(form.insertButtonView.isEnabled).toBe(false);
            form.fire("submit");

            expect(getTableSize(editor)).toBeNull();
            expect(balloon.visibleView).toBe(form);

            editor.disableReadOnlyMode("spec");
            expect(form.insertButtonView.isEnabled).toBe(true);
        });

        it("translates its strings", async () => {
            const translated = await createTestEditor([Essentials, Paragraph, TableInsertUI], {
                toolbar: ["insertTable"],
                translations: [{}, {
                    en: {
                        dictionary: {
                            "Insert table…": "Tabel personalizat…",
                            "Table size": "Dimensiune",
                            "Table headers": "Antet",
                            "Rows": "Rânduri",
                            "Columns": "Coloane",
                            "Use headers": "Cu antet",
                            "Header columns": "Coloane antet",
                            "Header rows": "Rânduri antet",
                            "Enter a whole number between 1 and %0.": "Între 1 și %0.",
                            "Enter a whole number between 0 and %0.": "Între 0 și %0."
                        }
                    }
                }]
            });
            const dropdown = getToolbarDropdown(translated);
            dropdown.isOpen = true;
            expect(getFormButton(dropdown).textContent).toBe("Tabel personalizat…");

            getFormButton(dropdown).click();
            const form = getForm(translated.plugins.get(ContextualBalloon));
            const headings = Array.from(getElement(form)
                .querySelectorAll(".ck-table-insert-form__card-heading"))
                .map((heading) => heading.textContent);
            expect(headings).toEqual(["Dimensiune", "Antet"]);
            const labels = Array.from(getElement(form).querySelectorAll("label"))
                .map((label) => label.textContent);
            expect(labels).toEqual(["Coloane", "Rânduri", "Coloane antet", "Rânduri antet"]);
            expect(getElement(form.headersSwitchView).textContent).toBe("Cu antet");

            getInput(form, "rows").value = "0";
            form.useHeaders = true;
            getInput(form, "headingColumns").value = "9";
            form.validate();
            expect(form.rowsField.errorText).toBe("Între 1 și 1000.");
            expect(form.headingColumnsField.errorText).toBe(`Între 0 și ${DEFAULT_TABLE_SIZE}.`);
        });
    });

    describe("in a block toolbar", () => {
        it("hides the block toolbar and focuses the form", async () => {
            const blockEditor = await createTestEditor(
                [Essentials, Paragraph, Table, TableInsertUI, BlockToolbar],
                { toolbar: [], blockToolbar: ["insertTable"] }
            );
            setModelData(blockEditor.model, "<paragraph>foo[]</paragraph>");
            blockEditor.editing.view.focus();

            const blockToolbar = blockEditor.plugins.get(BlockToolbar);
            blockToolbar.panelView.isVisible = true;
            const dropdown = getDropdown(blockToolbar.toolbarView.items.first);
            dropdown.isOpen = true;

            getFormButton(dropdown).click();

            expect(blockToolbar.panelView.isVisible).toBe(false);
            const form = getForm(blockEditor.plugins.get(ContextualBalloon));
            expect(document.activeElement).toBe(getInput(form, "columns"));
        });
    });
});

function getElement(view: { element: HTMLElement | null }): HTMLElement {
    if (!view.element) {
        throw new Error("The view is not rendered.");
    }
    return view.element;
}

function getDropdown(view: unknown): DropdownView {
    expect(view).toBeInstanceOf(DropdownView);
    return view as DropdownView;
}

function getToolbarDropdown(editor: ClassicEditor): DropdownView {
    return getDropdown(editor.ui.view.toolbar.items.first);
}

async function openDropdown(dropdown: DropdownView) {
    await userEvent.click(getElement(dropdown.buttonView));
    expect(dropdown.isOpen).toBe(true);
}

function getFormButton(dropdown: DropdownView): HTMLElement {
    const button = getElement(dropdown.panelView)
        .querySelector<HTMLElement>(".ck-insert-table-dropdown__content .ck-list__item > button");
    if (!button) {
        throw new Error("The dropdown has no Insert table… button.");
    }
    return button;
}

function getForm(balloon: ContextualBalloon): TableInsertFormView {
    const form = balloon.visibleView;
    expect(form).toBeInstanceOf(TableInsertFormView);
    return form as TableInsertFormView;
}

async function openForm(editor: ClassicEditor): Promise<TableInsertFormView> {
    const dropdown = getToolbarDropdown(editor);
    await openDropdown(dropdown);
    await userEvent.click(getFormButton(dropdown));
    return getForm(editor.plugins.get(ContextualBalloon));
}

function getInput(
    form: TableInsertFormView,
    field: "rows" | "columns" | "headingRows" | "headingColumns"
): HTMLInputElement {
    return getElement(form[`${field}Field`].inputView) as HTMLInputElement;
}

/** The size of the table in the document, or `null` when there is none. */
function getTableSize(editor: ClassicEditor): { rows: number; columns: number } | null {
    const table = findTable(editor);
    if (!table) {
        return null;
    }

    const tableUtils = editor.plugins.get(TableUtils);
    return { rows: tableUtils.getRows(table), columns: tableUtils.getColumns(table) };
}

/** The number of header rows and columns of the table in the document. */
function getTableHeadings(editor: ClassicEditor): { rows: number; columns: number } {
    const table = findTable(editor);
    if (!table) {
        throw new Error("The document has no table.");
    }

    return {
        rows: Number(table.getAttribute("headingRows") ?? 0),
        columns: Number(table.getAttribute("headingColumns") ?? 0)
    };
}

function findTable(editor: ClassicEditor): ModelElement | undefined {
    const root = editor.model.document.getRoot();
    const children = root ? Array.from(root.getChildren()) : [];
    return children.find((child) => child.is("element", "table")) as ModelElement | undefined;
}

function getCaretRect(editor: ClassicEditor): DOMRect {
    const view = editor.editing.view;
    const range = view.document.selection.getFirstRange();
    if (!range) {
        throw new Error("The editing view has no selection.");
    }
    return view.domConverter.viewRangeToDom(range).getBoundingClientRect();
}

function createEscEvent() {
    return {
        keyCode: keyCodes.esc,
        altKey: false,
        ctrlKey: false,
        metaKey: false,
        shiftKey: false,
        preventDefault: () => undefined,
        stopPropagation: () => undefined
    };
}