feat(boards): add responsive layout system (#2271)

This commit is contained in:
Meier Lukas authored and GitHub committed 2025-02-23 17:34:56 +01:00
1 parent 2085b5ece2
commit 7761dc29c8
98 files changed
+11770 -1694

No files matched your search

@@ -1,61 +1,109 @@
import { describe, expect, test, vi } from "vitest";
import type { Board } from "~/app/[locale]/boards/_types";
import * as boardContext from "@homarr/boards/context";
import { createItemCallback } from "../create-item";
import * as emptyPosition from "../empty-position";
import { createDynamicSection, createEmptySection, createItem } from "./shared";
import * as emptyPositionModule from "../empty-position";
import { BoardMockBuilder } from "./mocks/board-mock";
import { DynamicSectionMockBuilder } from "./mocks/dynamic-section-mock";
import { ItemMockBuilder } from "./mocks/item-mock";
import { LayoutMockBuilder } from "./mocks/layout-mock";
describe("item actions create-item", () => {
test("should add it to first section", () => {
const spy = vi.spyOn(emptyPosition, "getFirstEmptyPosition");
spy.mockReturnValue({ xOffset: 5, yOffset: 5 });
const input = {
sections: [createEmptySection("1", 2), createEmptySection("2", 0), createEmptySection("3", 1)],
columnCount: 4,
} satisfies Pick<Board, "sections" | "columnCount">;
// Arrange
const itemKind = "clock";
const emptyPosition = { xOffset: 5, yOffset: 5 };
const firstSectionId = "2";
const layoutId = "1";
const layout = new LayoutMockBuilder({ id: layoutId, columnCount: 4 }).build();
const board = new BoardMockBuilder()
.addLayout(layout)
.addLayout()
.addEmptySection({ id: "1", yOffset: 2 })
.addEmptySection({ id: firstSectionId, yOffset: 0 })
.addEmptySection({ id: "3", yOffset: 1 })
.build();
const emptyPositionSpy = vi.spyOn(emptyPositionModule, "getFirstEmptyPosition");
emptyPositionSpy.mockReturnValue(emptyPosition);
const layoutsSpy = vi.spyOn(boardContext, "getBoardLayouts");
layoutsSpy.mockReturnValue([layoutId]);
// Act
const result = createItemCallback({
kind: "clock",
})(input as unknown as Board);
kind: itemKind,
})(board);
const firstSection = result.sections.find((section) => section.id === "2");
const item = firstSection?.items.at(0);
expect(item).toEqual(expect.objectContaining({ kind: "clock", xOffset: 5, yOffset: 5 }));
expect(spy).toHaveBeenCalledWith([], input.columnCount);
// Assert
const item = result.items.at(0);
expect(item).toEqual(
expect.objectContaining({
kind: itemKind,
layouts: [
{
layoutId,
height: 1,
width: 1,
...emptyPosition,
sectionId: firstSectionId,
},
],
}),
);
expect(emptyPositionSpy).toHaveBeenCalledWith([], layout.columnCount);
});
test("should correctly pass dynamic section and items to getFirstEmptyPosition", () => {
const spy = vi.spyOn(emptyPosition, "getFirstEmptyPosition");
spy.mockReturnValue({ xOffset: 5, yOffset: 5 });
const firstSection = createEmptySection("2", 0);
const expectedItem = createItem({ id: "12", xOffset: 1, yOffset: 2, width: 3, height: 2 });
firstSection.items.push(expectedItem);
const dynamicSectionInFirst = createDynamicSection({
id: "4",
parentSectionId: "2",
yOffset: 0,
xOffset: 0,
width: 2,
height: 2,
});
// Arrange
const itemKind = "clock";
const emptyPosition = { xOffset: 5, yOffset: 5 };
const firstSectionId = "2";
const layoutId = "1";
const itemAndSectionPosition = { height: 2, width: 3, yOffset: 2, xOffset: 1 };
const input = {
sections: [
createEmptySection("1", 2),
firstSection,
createEmptySection("3", 1),
dynamicSectionInFirst,
createDynamicSection({ id: "5", parentSectionId: "3", yOffset: 1 }),
],
columnCount: 4,
} satisfies Pick<Board, "sections" | "columnCount">;
const layout = new LayoutMockBuilder({ id: layoutId, columnCount: 4 }).build();
const dynamicSectionInFirstSection = new DynamicSectionMockBuilder({ id: "4" })
.addLayout({ ...itemAndSectionPosition, layoutId, parentSectionId: firstSectionId })
.build();
const itemInFirstSection = new ItemMockBuilder({ id: "12" })
.addLayout({ ...itemAndSectionPosition, layoutId, sectionId: firstSectionId })
.build();
const otherDynamicSection = new DynamicSectionMockBuilder({ id: "5" }).addLayout({ layoutId }).build();
const otherItem = new ItemMockBuilder({ id: "13" }).addLayout({ layoutId }).build();
const board = new BoardMockBuilder()
.addLayout(layout)
.addEmptySection({ id: "1", yOffset: 2 })
.addEmptySection({ id: firstSectionId, yOffset: 0 })
.addEmptySection({ id: "3", yOffset: 1 })
.addSection(dynamicSectionInFirstSection)
.addSection(otherDynamicSection)
.addItem(itemInFirstSection)
.addItem(otherItem)
.build();
const spy = vi.spyOn(emptyPositionModule, "getFirstEmptyPosition");
spy.mockReturnValue(emptyPosition);
const layoutsSpy = vi.spyOn(boardContext, "getBoardLayouts");
layoutsSpy.mockReturnValue([layoutId]);
// Act
const result = createItemCallback({
kind: "clock",
})(input as unknown as Board);
kind: itemKind,
})(board);
const firstSectionResult = result.sections.find((section) => section.id === "2");
const item = firstSectionResult?.items.find((item) => item.id !== "12");
expect(item).toEqual(expect.objectContaining({ kind: "clock", xOffset: 5, yOffset: 5 }));
expect(spy).toHaveBeenCalledWith([expectedItem, dynamicSectionInFirst], input.columnCount);
// Assert
expect(result.items.length).toBe(3);
const item = result.items.find((item) => item.id !== itemInFirstSection.id && item.id !== otherItem.id);
expect(item).toEqual(
expect.objectContaining({
kind: itemKind,
layouts: [{ ...emptyPosition, height: 1, width: 1, sectionId: firstSectionId, layoutId }],
}),
);
expect(spy).toHaveBeenCalledWith(
[expect.objectContaining(itemAndSectionPosition), expect.objectContaining(itemAndSectionPosition)],
layout.columnCount,
);
});
});
@@ -1,51 +1,63 @@
import { describe, expect, test, vi } from "vitest";
import type { Board } from "~/app/[locale]/boards/_types";
import { duplicateItemCallback } from "../duplicate-item";
import * as emptyPosition from "../empty-position";
import { createEmptySection, createItem } from "./shared";
import * as emptyPositionModule from "../empty-position";
import { BoardMockBuilder } from "./mocks/board-mock";
import { ItemMockBuilder } from "./mocks/item-mock";
import { LayoutMockBuilder } from "./mocks/layout-mock";
describe("item actions duplicate-item", () => {
test("should copy it in the same section", () => {
const spy = vi.spyOn(emptyPosition, "getFirstEmptyPosition");
spy.mockReturnValue({ xOffset: 5, yOffset: 5 });
const currentSection = createEmptySection("2", 1);
const currentItem = createItem({
id: "1",
xOffset: 1,
yOffset: 3,
width: 3,
height: 2,
kind: "minecraftServerStatus",
// Arrange
const itemKind = "minecraftServerStatus";
const emptyPosition = { xOffset: 5, yOffset: 5 };
const currentSectionId = "2";
const layoutId = "1";
const currentItemSize = { height: 2, width: 3 };
const layout = new LayoutMockBuilder({ id: layoutId, columnCount: 4 }).build();
const currentItem = new ItemMockBuilder({
kind: itemKind,
integrationIds: ["1"],
options: { address: "localhost" },
advancedOptions: { customCssClasses: ["test"] },
});
const otherItem = createItem({
id: "2",
});
currentSection.items.push(currentItem, otherItem);
const input = {
columnCount: 10,
sections: [createEmptySection("1", 0), currentSection, createEmptySection("3", 2)],
} satisfies Pick<Board, "sections" | "columnCount">;
})
.addLayout({ layoutId, sectionId: currentSectionId, ...currentItemSize })
.build();
const otherItem = new ItemMockBuilder({ id: "2" }).addLayout({ layoutId }).build();
const result = duplicateItemCallback({ itemId: currentItem.id })(input as unknown as Board);
const board = new BoardMockBuilder()
.addLayout(layout)
.addItem(currentItem)
.addItem(otherItem)
.addEmptySection({ id: "1", yOffset: 2 })
.addEmptySection({ id: currentSectionId, yOffset: 0 })
.addEmptySection({ id: "3", yOffset: 1 })
.build();
const section = result.sections.find((section) => section.id === "2");
expect(section?.items.length).toBe(3);
const duplicatedItem = section?.items.find((item) => item.id !== currentItem.id && item.id !== otherItem.id);
const spy = vi.spyOn(emptyPositionModule, "getFirstEmptyPosition");
spy.mockReturnValue(emptyPosition);
// Act
const result = duplicateItemCallback({ itemId: currentItem.id })(board);
// Assert
expect(result.items.length).toBe(3);
const duplicatedItem = result.items.find((item) => item.id !== currentItem.id && item.id !== otherItem.id);
expect(duplicatedItem).toEqual(
expect.objectContaining({
kind: "minecraftServerStatus",
xOffset: 5,
yOffset: 5,
width: 3,
height: 2,
integrationIds: ["1"],
options: { address: "localhost" },
advancedOptions: { customCssClasses: ["test"] },
kind: itemKind,
integrationIds: currentItem.integrationIds,
options: currentItem.options,
advancedOptions: currentItem.advancedOptions,
layouts: [
expect.objectContaining({
...emptyPosition,
...currentItemSize,
sectionId: currentSectionId,
}),
],
}),
);
});
@@ -109,7 +109,7 @@ describe("get first empty position", () => {
});
const createElementsFromLayout = (layout: string[][]) => {
const elements: (Pick<Item, "xOffset" | "yOffset" | "width" | "height"> & { char: string })[] = [];
const elements: (Pick<Item["layouts"][number], "xOffset" | "yOffset" | "width" | "height"> & { char: string })[] = [];
for (let yOffset = 0; yOffset < layout.length; yOffset++) {
const row = layout[yOffset];
if (!row) continue;
@@ -0,0 +1,90 @@
import { createId } from "@homarr/db";
import type { Board, DynamicSection, EmptySection, Item, Section } from "~/app/[locale]/boards/_types";
import { DynamicSectionMockBuilder } from "./dynamic-section-mock";
import { EmptySectionMockBuilder } from "./empty-section-mock";
import { ItemMockBuilder } from "./item-mock";
import { LayoutMockBuilder } from "./layout-mock";
export class BoardMockBuilder {
private readonly board: Board;
constructor(board?: Partial<Omit<Board, "groupPermissions" | "userPermissions" | "sections" | "items" | "layouts">>) {
this.board = {
id: createId(),
backgroundImageRepeat: "no-repeat",
backgroundImageAttachment: "scroll",
backgroundImageSize: "cover",
backgroundImageUrl: null,
primaryColor: "#ffffff",
secondaryColor: "#000000",
iconColor: null,
itemRadius: "lg",
pageTitle: "Board",
metaTitle: "Board",
logoImageUrl: null,
faviconImageUrl: null,
name: "board",
opacity: 100,
isPublic: true,
disableStatus: false,
customCss: "",
creatorId: createId(),
creator: {
id: createId(),
image: null,
name: "User",
},
groupPermissions: [],
userPermissions: [],
sections: [],
items: [],
layouts: [
{
id: createId(),
name: "Base",
columnCount: 12,
breakpoint: 0,
},
],
...board,
};
}
public addEmptySection(emptySection?: Partial<EmptySection>): BoardMockBuilder {
return this.addSection(new EmptySectionMockBuilder(emptySection).build());
}
public addDynamicSection(dynamicSection?: Partial<DynamicSection>): BoardMockBuilder {
return this.addSection(new DynamicSectionMockBuilder(dynamicSection).build());
}
public addSection(section: Section): BoardMockBuilder {
this.board.sections.push(section);
return this;
}
public addSections(sections: Section[]): BoardMockBuilder {
this.board.sections.push(...sections);
return this;
}
public addItem(item?: Partial<Item>): BoardMockBuilder {
this.board.items.push(new ItemMockBuilder(item).build());
return this;
}
public addItems(items: Item[]): BoardMockBuilder {
this.board.items.push(...items);
return this;
}
public addLayout(layout?: Partial<Board["layouts"][number]>): BoardMockBuilder {
this.board.layouts.push(new LayoutMockBuilder(layout).build());
return this;
}
public build(): Board {
return this.board;
}
}
@@ -0,0 +1,23 @@
import { createId } from "@homarr/db";
import type { CategorySection } from "~/app/[locale]/boards/_types";
export class CategorySectionMockBuilder {
private readonly section: CategorySection;
constructor(section?: Partial<CategorySection>) {
this.section = {
id: createId(),
kind: "category",
xOffset: 0,
yOffset: 0,
name: "Category",
collapsed: false,
...section,
} satisfies CategorySection;
}
public build(): CategorySection {
return this.section;
}
}
@@ -0,0 +1,33 @@
import { createId } from "@homarr/db";
import type { DynamicSection } from "~/app/[locale]/boards/_types";
export class DynamicSectionMockBuilder {
private readonly section: DynamicSection;
constructor(section?: Partial<DynamicSection>) {
this.section = {
id: createId(),
kind: "dynamic",
layouts: [],
...section,
} satisfies DynamicSection;
}
public addLayout(layout?: Partial<DynamicSection["layouts"][0]>): DynamicSectionMockBuilder {
this.section.layouts.push({
layoutId: "1",
height: 1,
width: 1,
xOffset: 0,
yOffset: 0,
parentSectionId: "0",
...layout,
} satisfies DynamicSection["layouts"][0]);
return this;
}
public build(): DynamicSection {
return this.section;
}
}
@@ -0,0 +1,21 @@
import { createId } from "@homarr/db";
import type { EmptySection } from "~/app/[locale]/boards/_types";
export class EmptySectionMockBuilder {
private readonly section: EmptySection;
constructor(section?: Partial<EmptySection>) {
this.section = {
id: createId(),
kind: "empty",
xOffset: 0,
yOffset: 0,
...section,
} satisfies EmptySection;
}
public build(): EmptySection {
return this.section;
}
}
@@ -0,0 +1,38 @@
import { createId } from "@homarr/db";
import type { Item } from "~/app/[locale]/boards/_types";
export class ItemMockBuilder {
private readonly item: Item;
constructor(item?: Partial<Item>) {
this.item = {
id: createId(),
kind: "app",
options: {},
layouts: [],
integrationIds: [],
advancedOptions: {
customCssClasses: [],
},
...item,
} satisfies Item;
}
public addLayout(layout?: Partial<Item["layouts"][0]>): ItemMockBuilder {
this.item.layouts.push({
layoutId: "1",
height: 1,
width: 1,
xOffset: 0,
yOffset: 0,
sectionId: "0",
...layout,
} satisfies Item["layouts"][0]);
return this;
}
public build(): Item {
return this.item;
}
}
@@ -0,0 +1,21 @@
import { createId } from "@homarr/db";
import type { Board } from "~/app/[locale]/boards/_types";
export class LayoutMockBuilder {
private readonly layout: Board["layouts"][number];
constructor(layout?: Partial<Board["layouts"][number]>) {
this.layout = {
id: createId(),
name: "Base",
columnCount: 12,
breakpoint: 0,
...layout,
} satisfies Board["layouts"][0];
}
public build(): Board["layouts"][0] {
return this.layout;
}
}
@@ -0,0 +1,65 @@
import { describe, expect, test, vi } from "vitest";
import * as boardContext from "@homarr/boards/context";
import { moveAndResizeItemCallback } from "../move-and-resize-item";
import { BoardMockBuilder } from "./mocks/board-mock";
import { ItemMockBuilder } from "./mocks/item-mock";
describe("moveItemToSectionCallback should move item in section", () => {
test("should move item in section", () => {
// Arrange
const itemToMove = "2";
const layoutId = "1";
const spy = vi.spyOn(boardContext, "getCurrentLayout");
spy.mockReturnValue(layoutId);
const newPosition = {
xOffset: 20,
yOffset: 30,
width: 15,
height: 17,
};
const itemA = new ItemMockBuilder().addLayout({ layoutId }).build();
const itemB = new ItemMockBuilder({ id: itemToMove }).addLayout({ layoutId }).addLayout().build();
const itemC = new ItemMockBuilder().addLayout({ layoutId }).build();
const board = new BoardMockBuilder().addItem(itemA).addItem(itemB).addItem(itemC).build();
// Act
const updatedBoard = moveAndResizeItemCallback({ itemId: itemToMove, ...newPosition })(board);
// Assert
expect(updatedBoard.items).toHaveLength(3);
const movedItem = updatedBoard.items.find((item) => item.id === itemToMove);
expect(movedItem).not.toBeUndefined();
expect(movedItem?.layouts.find((layout) => layout.layoutId === layoutId)).toEqual(
expect.objectContaining(newPosition),
);
const otherItemLayouts = updatedBoard.items
.filter((item) => item.id !== itemToMove)
.flatMap((item) => item.layouts);
expect(otherItemLayouts).not.toContainEqual(expect.objectContaining(newPosition));
});
test("should not move item if item not found", () => {
// Arrange
const itemToMove = "2";
const layoutId = "1";
const spy = vi.spyOn(boardContext, "getCurrentLayout");
spy.mockReturnValue(layoutId);
const newPosition = {
xOffset: 20,
yOffset: 30,
width: 15,
height: 17,
};
const itemA = new ItemMockBuilder().addLayout({ layoutId }).build();
const itemC = new ItemMockBuilder().addLayout({ layoutId }).build();
const board = new BoardMockBuilder().addItem(itemA).addItem(itemC).build();
// Act
const updatedBoard = moveAndResizeItemCallback({ itemId: itemToMove, ...newPosition })(board);
// Assert
expect(updatedBoard.items).toHaveLength(2);
expect(updatedBoard.items.find((item) => item.layouts.at(0)?.yOffset === newPosition.yOffset)).toBeUndefined();
});
});
@@ -0,0 +1,67 @@
import { describe, expect, test, vi } from "vitest";
import * as boardContext from "@homarr/boards/context";
import { moveItemToSectionCallback } from "../move-item-to-section";
import { BoardMockBuilder } from "./mocks/board-mock";
import { ItemMockBuilder } from "./mocks/item-mock";
describe("moveItemToSectionCallback should move item to section", () => {
test("should move item to section", () => {
// Arrange
const itemToMove = "2";
const layoutId = "1";
const spy = vi.spyOn(boardContext, "getCurrentLayout");
spy.mockReturnValue(layoutId);
const newPosition = {
sectionId: "3",
xOffset: 20,
yOffset: 30,
width: 15,
height: 17,
};
const itemA = new ItemMockBuilder().addLayout({ layoutId }).build();
const itemB = new ItemMockBuilder({ id: itemToMove }).addLayout({ layoutId }).addLayout().build();
const itemC = new ItemMockBuilder().addLayout({ layoutId }).build();
const board = new BoardMockBuilder().addItem(itemA).addItem(itemB).addItem(itemC).build();
// Act
const updatedBoard = moveItemToSectionCallback({ itemId: itemToMove, ...newPosition })(board);
// Assert
expect(updatedBoard.items).toHaveLength(3);
const movedItem = updatedBoard.items.find((item) => item.id === itemToMove);
expect(movedItem).not.toBeUndefined();
expect(movedItem?.layouts.find((layout) => layout.layoutId === layoutId)).toEqual(
expect.objectContaining(newPosition),
);
const otherItemLayouts = updatedBoard.items
.filter((item) => item.id !== itemToMove)
.flatMap((item) => item.layouts);
expect(otherItemLayouts).not.toContainEqual(expect.objectContaining(newPosition));
});
test("should not move item if item not found", () => {
// Arrange
const itemToMove = "2";
const layoutId = "1";
const spy = vi.spyOn(boardContext, "getCurrentLayout");
spy.mockReturnValue(layoutId);
const newPosition = {
sectionId: "3",
xOffset: 20,
yOffset: 30,
width: 15,
height: 17,
};
const itemA = new ItemMockBuilder().addLayout({ layoutId }).build();
const itemC = new ItemMockBuilder().addLayout({ layoutId }).build();
const board = new BoardMockBuilder().addItem(itemA).addItem(itemC).build();
// Act
const updatedBoard = moveItemToSectionCallback({ itemId: itemToMove, ...newPosition })(board);
// Assert
expect(updatedBoard.items).toHaveLength(2);
expect(updatedBoard.items.find((item) => item.layouts.at(0)?.sectionId === newPosition.sectionId)).toBeUndefined();
});
});
@@ -0,0 +1,37 @@
import { describe, expect, test } from "vitest";
import { removeItemCallback } from "../remove-item";
import { BoardMockBuilder } from "./mocks/board-mock";
describe("removeItemCallback should remove item from board", () => {
test("should remove correct item from board", () => {
// Arrange
const itemIdToRemove = "2";
const board = new BoardMockBuilder()
.addItem({ id: "1" })
.addItem({ id: itemIdToRemove })
.addItem({ id: "3" })
.build();
// Act
const updatedBoard = removeItemCallback({ itemId: itemIdToRemove })(board);
// Assert
const itemIds = updatedBoard.items.map((item) => item.id);
expect(itemIds).toHaveLength(2);
expect(itemIds).not.toContain(itemIdToRemove);
});
test("should not remove item if item not found", () => {
// Arrange
const itemIdToRemove = "2";
const board = new BoardMockBuilder().addItem({ id: "1" }).addItem({ id: "3" }).build();
// Act
const updatedBoard = removeItemCallback({ itemId: itemIdToRemove })(board);
// Assert
const itemIds = updatedBoard.items.map((item) => item.id);
expect(itemIds).toHaveLength(2);
expect(itemIds).not.toContain(itemIdToRemove);
});
});
@@ -1,32 +0,0 @@
import type { DynamicSection, EmptySection, Item } from "~/app/[locale]/boards/_types";
export const createEmptySection = (id: string, yOffset: number): EmptySection => ({
id,
kind: "empty",
yOffset,
xOffset: 0,
items: [],
});
export const createDynamicSection = (section: Omit<Partial<DynamicSection>, "kind">): DynamicSection => ({
id: section.id ?? "0",
kind: "dynamic",
parentSectionId: section.parentSectionId ?? "0",
height: section.height ?? 1,
width: section.width ?? 1,
yOffset: section.yOffset ?? 0,
xOffset: section.xOffset ?? 0,
items: section.items ?? [],
});
export const createItem = (item: Partial<Item>): Item => ({
id: item.id ?? "0",
width: item.width ?? 1,
height: item.height ?? 1,
yOffset: item.yOffset ?? 0,
xOffset: item.xOffset ?? 0,
kind: item.kind ?? "clock",
integrationIds: item.integrationIds ?? [],
options: item.options ?? {},
advancedOptions: item.advancedOptions ?? { customCssClasses: [] },
});