style: auto-fix lint and format

Wrap getInitialBoardAsync in React cache() so the same board data is
fetched once per request instead of 3 times (layout, page, metadata).
This is the same pattern used for auth() in the codebase.

apps/nextjs/src/app/[locale]/boards/(content)/(home)/_definition.ts

@@ -1,9 +1,11 @@
+import { cache } from "react";
+
 import { api } from "@homarr/api/server";
 
 import { createBoardContentPage } from "../_creator";
 
+const getHomeBoardAsync = cache(() => api.board.getHomeBoard());
+
 export default createBoardContentPage<{ locale: string }>({
-  async getInitialBoardAsync() {
-    return await api.board.getHomeBoard();
-  },
+  getInitialBoardAsync: getHomeBoardAsync,
 });

apps/nextjs/src/app/[locale]/boards/(content)/[name]/(board)/_definition.tsx

@@ -1,9 +1,11 @@
+import { cache } from "react";
+
 import { api } from "@homarr/api/server";
 
 import { createBoardContentPage } from "../../_creator";
 
+const getBoardByNameAsync = cache((name: string) => api.board.getBoardByName({ name }));
+
 export default createBoardContentPage<{ locale: string; name: string }>({
-  async getInitialBoardAsync({ name }) {
-    return await api.board.getBoardByName({ name });
-  },
+  getInitialBoardAsync: async ({ name }) => getBoardByNameAsync(name),
 });

apps/nextjs/src/app/[locale]/boards/(content)/_client.tsx

@@ -1,33 +1,24 @@
 "use client";
 
-import { Box, Stack } from "@mantine/core";
+import dynamic from "next/dynamic";
+import { Box } from "@mantine/core";
 
-import { useCurrentLayout, useRequiredBoard } from "@homarr/boards/context";
+import { useRequiredBoard } from "@homarr/boards/context";
+import { useEditMode } from "@homarr/boards/edit-mode";
 
-import { BoardCategorySection } from "~/components/board/sections/category-section";
-import { BoardEmptySection } from "~/components/board/sections/empty-section";
+import { StaticBoardGrid } from "~/components/board/sections/static-grid";
 import { BoardBackgroundVideo } from "~/components/layout/background";
 
+const EditModeBoard = dynamic(() => import("./_edit-board"), { ssr: false });
+
 export const ClientBoard = () => {
   const board = useRequiredBoard();
-  const currentLayoutId = useCurrentLayout();
-
-  const fullWidthSortedSections = board.sections
-    .filter((section) => section.kind === "empty" || section.kind === "category")
-    .sort((sectionA, sectionB) => sectionA.yOffset - sectionB.yOffset);
+  const [isEditMode] = useEditMode();
 
   return (
     <Box h="100%" pos="relative">
       <BoardBackgroundVideo />
-      <Stack h="100%">
-        {fullWidthSortedSections.map((section) =>
-          section.kind === "empty" ? (
-            <BoardEmptySection key={`${currentLayoutId}-${section.id}`} section={section} />
-          ) : (
-            <BoardCategorySection key={`${currentLayoutId}-${section.id}`} section={section} />
-          ),
-        )}
-      </Stack>
+      {isEditMode ? <EditModeBoard /> : <StaticBoardGrid board={board} />}
     </Box>
   );
 };

apps/nextjs/src/app/[locale]/boards/(content)/_dynamic-client.tsx

@@ -1,7 +1,3 @@
 "use client";
 
-import dynamic from "next/dynamic";
-
-export const DynamicClientBoard = dynamic(() => import("./_client").then((mod) => mod.ClientBoard), {
-  ssr: false,
-});
+export { ClientBoard as DynamicClientBoard } from "./_client";

apps/nextjs/src/app/[locale]/boards/(content)/_edit-board.tsx

@@ -0,0 +1,31 @@
+"use client";
+
+import { Stack } from "@mantine/core";
+
+import { useCurrentLayout, useRequiredBoard } from "@homarr/boards/context";
+
+import { BoardCategorySection } from "~/components/board/sections/category-section";
+import { BoardEmptySection } from "~/components/board/sections/empty-section";
+
+const EditModeBoard = () => {
+  const board = useRequiredBoard();
+  const currentLayoutId = useCurrentLayout();
+
+  const fullWidthSortedSections = board.sections
+    .filter((section) => section.kind === "empty" || section.kind === "category")
+    .toSorted((sectionA, sectionB) => sectionA.yOffset - sectionB.yOffset);
+
+  return (
+    <Stack h="100%">
+      {fullWidthSortedSections.map((section) =>
+        section.kind === "empty" ? (
+          <BoardEmptySection key={`${currentLayoutId}-${section.id}`} section={section} />
+        ) : (
+          <BoardCategorySection key={`${currentLayoutId}-${section.id}`} section={section} />
+        ),
+      )}
+    </Stack>
+  );
+};
+
+export default EditModeBoard;

apps/nextjs/src/app/[locale]/manage/integrations/new/_integration-new-form.tsx

@@ -148,9 +148,7 @@ export const NewIntegrationForm = ({ searchParams }: NewIntegrationFormProps) =>
     );
   };
 
-  const integrationCategories = integrationDefs[searchParams.kind].category.flat();
-  const supportsSearchEngine =
-    integrationCategories.includes("search") && !integrationCategories.includes("mediaSearch");
+  const supportsSearchEngine = integrationDefs[searchParams.kind].category.flat().includes("search");
 
   return (
     <form onSubmit={form.onSubmit((value) => void handleSubmitAsync(value))}>

apps/nextjs/src/components/board/items/item-content.tsx

@@ -19,6 +19,10 @@ import { BoardItemMenu } from "./item-menu";
 
 interface BoardItemContentProps {
   item: SectionItem;
+  fallbackDimensions?: {
+    width: number;
+    height: number;
+  };
 }
 
 const getOverflowFromKind = (kind: SectionItem["kind"]) => {
@@ -27,9 +31,11 @@ const getOverflowFromKind = (kind: SectionItem["kind"]) => {
   return undefined;
 };
 
-export const BoardItemContent = ({ item }: BoardItemContentProps) => {
+export const BoardItemContent = ({ item, fallbackDimensions }: BoardItemContentProps) => {
   const { ref, width, height } = useElementSize<HTMLDivElement>();
   const board = useRequiredBoard();
+  const fallbackWidth = fallbackDimensions?.width ?? 0;
+  const fallbackHeight = fallbackDimensions?.height ?? 0;
 
   return (
     <>
@@ -52,7 +58,7 @@ export const BoardItemContent = ({ item }: BoardItemContentProps) => {
         }}
         p={0}
       >
-        <InnerContent item={item} width={width} height={height} />
+        <InnerContent item={item} width={width || fallbackWidth} height={height || fallbackHeight} />
       </Card>
       {item.advancedOptions.title?.trim() && (
         <Badge

apps/nextjs/src/components/board/items/item-menu.tsx

@@ -12,7 +12,7 @@ import { widgetImports } from "@homarr/widgets";
 import { WidgetEditModal } from "@homarr/widgets/modals";
 
 import type { SectionItem } from "~/app/[locale]/boards/_types";
-import { useSectionContext } from "../sections/section-context";
+import { useOptionalSectionContext } from "../sections/section-context";
 import { useItemActions } from "./item-actions";
 import { ItemMoveModal } from "./item-move-modal";
 
@@ -41,7 +41,8 @@ const BoardItemMenuInner = ({ offset, item, resetErrorBoundary }: BoardItemMenuP
     useItemActions();
   const { data: integrationData, isPending } = clientApi.integration.all.useQuery();
   const currentDefinition = useMemo(() => widgetImports[item.kind].definition, [item.kind]);
-  const { gridstack } = useSectionContext().refs;
+  const sectionContext = useOptionalSectionContext();
+  const gridstack = sectionContext?.refs.gridstack;
   const settings = useSettings();
 
   // Reset error boundary on next render if item has been edited
@@ -85,7 +86,6 @@ const BoardItemMenuInner = ({ offset, item, resetErrorBoundary }: BoardItemMenuP
         ),
         integrationSupport: "supportedIntegrations" in currentDefinition,
         settings,
-        appId: item.kind === "app" ? (item.options.appId as string | undefined) : undefined,
       },
       {
         title(t) {
@@ -128,7 +128,7 @@ const BoardItemMenuInner = ({ offset, item, resetErrorBoundary }: BoardItemMenuP
         <Menu.Item
           leftSection={<IconLayoutKanban size={16} />}
           onClick={() => {
-            if (!gridstack.current) return;
+            if (!gridstack?.current) return;
             openMoveModal({ item, columnCount: gridstack.current.getColumn(), gridStack: gridstack.current });
           }}
         >

apps/nextjs/src/components/board/sections/category-section.tsx

@@ -1,48 +1,21 @@
 import { Card, Collapse, Group, Stack, Title, UnstyledButton } from "@mantine/core";
-import { useDisclosure } from "@mantine/hooks";
 import { IconChevronDown, IconChevronUp } from "@tabler/icons-react";
 
-import { clientApi } from "@homarr/api/client";
-import { useSession } from "@homarr/auth/client";
 import { useRequiredBoard } from "@homarr/boards/context";
 
 import type { CategorySection } from "~/app/[locale]/boards/_types";
 import { CategoryMenu } from "./category/category-menu";
 import { GridStack } from "./gridstack/gridstack";
 import classes from "./item.module.css";
-
-const localStorageKey = (sectionId: string) => `homarr-section-collapsed-${sectionId}`;
+import { useCategoryCollapse } from "./use-category-collapse";
 
 interface Props {
   section: CategorySection;
 }
 
 export const BoardCategorySection = ({ section }: Props) => {
-  const { status } = useSession();
-  const { mutate } = clientApi.section.changeCollapsed.useMutation();
   const board = useRequiredBoard();
-
-  const initialCollapsed =
-    typeof window !== "undefined"
-      ? (localStorage.getItem(localStorageKey(section.id)) ?? String(section.collapsed)) === "true"
-      : section.collapsed;
-
-  const [opened, { toggle }] = useDisclosure(initialCollapsed, {
-    onOpen() {
-      if (status === "authenticated") {
-        mutate({ sectionId: section.id, collapsed: true });
-      } else if (status === "unauthenticated") {
-        localStorage.setItem(localStorageKey(section.id), "true");
-      }
-    },
-    onClose() {
-      if (status === "authenticated") {
-        mutate({ sectionId: section.id, collapsed: false });
-      } else if (status === "unauthenticated") {
-        localStorage.setItem(localStorageKey(section.id), "false");
-      }
-    },
-  });
+  const [opened, { toggle }] = useCategoryCollapse(section);
 
   return (
     <Card style={{ "--opacity": board.opacity / 100 }} radius={board.itemRadius} p={0} className={classes.itemCard}>

apps/nextjs/src/components/board/sections/section-context.ts

@@ -20,4 +20,8 @@ export const useSectionContext = () => {
   return context;
 };
 
+export const useOptionalSectionContext = () => {
+  return useContext(SectionContext);
+};
+
 export const SectionProvider = SectionContext.Provider;

apps/nextjs/src/components/board/sections/static-grid-layout.spec.ts

@@ -0,0 +1,93 @@
+import { describe, expect, test } from "vitest";
+
+import { BoardMockBuilder } from "../items/actions/test/mocks/board-mock";
+import { DynamicSectionMockBuilder } from "../items/actions/test/mocks/dynamic-section-mock";
+import { ItemMockBuilder } from "../items/actions/test/mocks/item-mock";
+import { LayoutMockBuilder } from "../items/actions/test/mocks/layout-mock";
+import {
+  getEstimatedGridWidth,
+  getFallbackDimensions,
+  getFullWidthSortedSections,
+  getStaticGridElements,
+  getStaticGridLayouts,
+  getStaticGridRowCount,
+  getStaticLayoutSelectionCss,
+} from "./static-grid-layout";
+
+describe("static grid layout", () => {
+  test("sorts layouts and creates breakpoint CSS in mobile-first order", () => {
+    const mobile = new LayoutMockBuilder({ id: "mobile", breakpoint: 0, columnCount: 4 }).build();
+    const tablet = new LayoutMockBuilder({ id: "tablet", breakpoint: 768, columnCount: 8 }).build();
+    const desktop = new LayoutMockBuilder({ id: "desktop", breakpoint: 1024, columnCount: 12 }).build();
+
+    const sortedLayouts = getStaticGridLayouts([desktop, mobile, tablet]);
+    const css = getStaticLayoutSelectionCss("board-1", sortedLayouts);
+
+    expect(sortedLayouts.map((layout) => layout.id)).toEqual(["mobile", "tablet", "desktop"]);
+    expect(css).toContain('[data-static-layout="mobile"] { display: block; }');
+    expect(css).toContain("@media (min-width: 768px)");
+    expect(css).toContain('[data-static-layout="tablet"] { display: block; }');
+    expect(css).toContain("@media (min-width: 1024px)");
+    expect(css).toContain('[data-static-layout="desktop"] { display: block; }');
+  });
+
+  test("selects and sorts layout-specific section elements", () => {
+    const rootSectionId = "root";
+    const mobileLayoutId = "mobile";
+    const desktopLayoutId = "desktop";
+    const mobile = new LayoutMockBuilder({ id: mobileLayoutId, breakpoint: 0, columnCount: 4 }).build();
+    const desktop = new LayoutMockBuilder({ id: desktopLayoutId, breakpoint: 1024, columnCount: 12 }).build();
+    const item = new ItemMockBuilder({ id: "item" })
+      .addLayout({ layoutId: mobileLayoutId, sectionId: rootSectionId, xOffset: 2, yOffset: 1, width: 1, height: 1 })
+      .addLayout({ layoutId: desktopLayoutId, sectionId: rootSectionId, xOffset: 0, yOffset: 1, width: 4, height: 2 })
+      .build();
+    const dynamicSection = new DynamicSectionMockBuilder({ id: "dynamic" })
+      .addLayout({
+        layoutId: mobileLayoutId,
+        parentSectionId: rootSectionId,
+        xOffset: 0,
+        yOffset: 0,
+        width: 2,
+        height: 2,
+      })
+      .addLayout({
+        layoutId: desktopLayoutId,
+        parentSectionId: rootSectionId,
+        xOffset: 4,
+        yOffset: 1,
+        width: 4,
+        height: 2,
+      })
+      .build();
+    const board = new BoardMockBuilder()
+      .addEmptySection({ id: rootSectionId, yOffset: 2 })
+      .addEmptySection({ id: "first", yOffset: 0 })
+      .addSection(dynamicSection)
+      .addItem(item)
+      .build();
+    board.layouts = [desktop, mobile];
+
+    const mobileElements = getStaticGridElements(board, rootSectionId, mobileLayoutId);
+    const desktopElements = getStaticGridElements(board, rootSectionId, desktopLayoutId);
+    const fullWidthSections = getFullWidthSortedSections(board);
+
+    expect(mobileElements.map((element) => element.id)).toEqual(["dynamic", "item"]);
+    expect(desktopElements.map((element) => ({ id: element.id, width: element.width }))).toEqual([
+      { id: "item", width: 4 },
+      { id: "dynamic", width: 4 },
+    ]);
+    expect(getStaticGridRowCount(mobileElements)).toBe(2);
+    expect(fullWidthSections.map((section) => section.id)).toEqual(["first", rootSectionId]);
+  });
+
+  test("estimates grid and item dimensions per layout range", () => {
+    const mobile = new LayoutMockBuilder({ id: "mobile", breakpoint: 0, columnCount: 4 }).build();
+    const tablet = new LayoutMockBuilder({ id: "tablet", breakpoint: 768, columnCount: 8 }).build();
+    const desktop = new LayoutMockBuilder({ id: "desktop", breakpoint: 1024, columnCount: 12 }).build();
+
+    expect(getEstimatedGridWidth(mobile, tablet)).toBe(384);
+    expect(getEstimatedGridWidth(tablet, desktop)).toBe(896);
+    expect(getEstimatedGridWidth(desktop)).toBe(1280);
+    expect(getFallbackDimensions({ width: 2, height: 3 }, 400, 4)).toEqual({ width: 180, height: 280 });
+  });
+});

apps/nextjs/src/components/board/sections/static-grid-layout.ts

@@ -0,0 +1,103 @@
+import type { Board, DynamicSectionItem, EmptySection, SectionItem } from "~/app/[locale]/boards/_types";
+
+type BoardLayout = Board["layouts"][number];
+type StaticGridElement = SectionItem | DynamicSectionItem;
+
+const STATIC_GRID_ITEM_INSET = 20;
+const DEFAULT_SMALL_VIEWPORT_WIDTH = 360;
+const DEFAULT_LARGE_VIEWPORT_WIDTH = 1280;
+
+export const getStaticGridLayouts = (layouts: Board["layouts"]) =>
+  [...layouts].toSorted((layoutA, layoutB) => layoutA.breakpoint - layoutB.breakpoint);
+
+const escapeCssString = (value: string) => value.replaceAll("\\", "\\\\").replaceAll('"', '\\"');
+
+export const getStaticLayoutSelectionCss = (boardId: string, layouts: Board["layouts"]) => {
+  const sortedLayouts = getStaticGridLayouts(layouts);
+  const initialLayout = sortedLayouts.at(0);
+
+  if (!initialLayout) return "";
+
+  const scope = `[data-static-board="${escapeCssString(boardId)}"]`;
+  const css = [
+    `${scope} .static-board-layout { display: none; }`,
+    `${scope} .static-board-layout[data-static-layout="${escapeCssString(initialLayout.id)}"] { display: block; }`,
+  ];
+
+  for (const layout of sortedLayouts.slice(1)) {
+    css.push(
+      `@media (min-width: ${layout.breakpoint}px) { ${scope} .static-board-layout { display: none; } ${scope} .static-board-layout[data-static-layout="${escapeCssString(layout.id)}"] { display: block; } }`,
+    );
+  }
+
+  return css.join("\n");
+};
+
+export const getFullWidthSortedSections = (board: Board) =>
+  board.sections
+    .filter(
+      (section): section is EmptySection | Extract<Board["sections"][number], { kind: "category" }> =>
+        section.kind === "empty" || section.kind === "category",
+    )
+    .sort((sectionA, sectionB) => sectionA.yOffset - sectionB.yOffset);
+
+export const getSectionItemsForLayout = (board: Board, sectionId: string, layoutId: string): SectionItem[] => {
+  return board.items
+    .map(({ layouts, ...item }) => {
+      const layout = layouts.find((candidate) => candidate.layoutId === layoutId);
+      if (!layout) return null;
+      return { ...layout, ...item, type: "item" as const };
+    })
+    .filter((item): item is SectionItem => item !== null && item.sectionId === sectionId);
+};
+
+export const getDynamicSectionsForLayout = (
+  board: Board,
+  sectionId: string,
+  layoutId: string,
+): DynamicSectionItem[] => {
+  return board.sections
+    .filter((section) => section.kind === "dynamic")
+    .map(({ layouts, ...section }) => {
+      const layout = layouts.find((candidate) => candidate.layoutId === layoutId);
+      if (!layout) return null;
+      return { ...layout, ...section, type: "section" as const };
+    })
+    .filter((entry): entry is DynamicSectionItem => entry !== null && entry.parentSectionId === sectionId);
+};
+
+export const getStaticGridElements = (board: Board, sectionId: string, layoutId: string): StaticGridElement[] => {
+  return [
+    ...getSectionItemsForLayout(board, sectionId, layoutId),
+    ...getDynamicSectionsForLayout(board, sectionId, layoutId),
+  ].toSorted((itemA, itemB) => {
+    if (itemA.yOffset === itemB.yOffset) return itemA.xOffset - itemB.xOffset;
+    return itemA.yOffset - itemB.yOffset;
+  });
+};
+
+export const getStaticGridRowCount = (items: StaticGridElement[], fixedRowCount?: number) => {
+  return fixedRowCount ?? Math.max(...items.map((item) => item.yOffset + item.height));
+};
+
+export const getEstimatedGridWidth = (layout: BoardLayout, nextLayout?: BoardLayout) => {
+  if (nextLayout) {
+    const upperBound = Math.max(nextLayout.breakpoint - 1, DEFAULT_SMALL_VIEWPORT_WIDTH);
+    return Math.max(DEFAULT_SMALL_VIEWPORT_WIDTH, Math.round((layout.breakpoint + upperBound) / 2));
+  }
+
+  return Math.max(layout.breakpoint, DEFAULT_LARGE_VIEWPORT_WIDTH);
+};
+
+export const getFallbackDimensions = (
+  item: Pick<StaticGridElement, "width" | "height">,
+  estimatedGridWidth: number,
+  columnCount: number,
+) => {
+  const cellSize = estimatedGridWidth / columnCount;
+
+  return {
+    width: Math.max(0, item.width * cellSize - STATIC_GRID_ITEM_INSET),
+    height: Math.max(0, item.height * cellSize - STATIC_GRID_ITEM_INSET),
+  };
+};

apps/nextjs/src/components/board/sections/static-grid.tsx

@@ -0,0 +1,289 @@
+"use client";
+
+import { Badge, Card, Collapse, Group, Stack, Title, UnstyledButton } from "@mantine/core";
+import { IconChevronDown, IconChevronUp } from "@tabler/icons-react";
+
+import { useRequiredBoard } from "@homarr/boards/context";
+
+import type {
+  Board,
+  CategorySection,
+  DynamicSectionItem,
+  EmptySection,
+  SectionItem,
+} from "~/app/[locale]/boards/_types";
+import { BoardItemContent } from "../items/item-content";
+import { CategoryMenu } from "./category/category-menu";
+import classes from "./item.module.css";
+import {
+  getEstimatedGridWidth,
+  getFallbackDimensions,
+  getFullWidthSortedSections,
+  getStaticGridElements,
+  getStaticGridLayouts,
+  getStaticGridRowCount,
+  getStaticLayoutSelectionCss,
+} from "./static-grid-layout";
+import { useCategoryCollapse } from "./use-category-collapse";
+
+interface StaticBoardGridProps {
+  board: Board;
+}
+
+export const StaticBoardGrid = ({ board }: StaticBoardGridProps) => {
+  const boardId = `board-${board.id}`;
+  const layouts = getStaticGridLayouts(board.layouts);
+  const layoutSelectionCss = getStaticLayoutSelectionCss(boardId, layouts);
+  const fullWidthSortedSections = getFullWidthSortedSections(board);
+
+  if (layouts.length === 0) return null;
+
+  return (
+    <>
+      <style>{layoutSelectionCss}</style>
+      <div data-static-board={boardId}>
+        {layouts.map((layout, index) => (
+          <div key={layout.id} className="static-board-layout" data-static-layout={layout.id}>
+            <Stack h="100%">
+              {fullWidthSortedSections.map((section) =>
+                section.kind === "empty" ? (
+                  <StaticEmptySection
+                    key={section.id}
+                    section={section}
+                    board={board}
+                    layoutId={layout.id}
+                    columnCount={layout.columnCount}
+                    estimatedGridWidth={getEstimatedGridWidth(layout, layouts.at(index + 1))}
+                  />
+                ) : (
+                  <StaticCategorySection
+                    key={section.id}
+                    section={section}
+                    board={board}
+                    layoutId={layout.id}
+                    columnCount={layout.columnCount}
+                    estimatedGridWidth={getEstimatedGridWidth(layout, layouts.at(index + 1))}
+                  />
+                ),
+              )}
+            </Stack>
+          </div>
+        ))}
+      </div>
+    </>
+  );
+};
+
+interface StaticSectionGridProps {
+  sectionId: string;
+  board: Board;
+  layoutId: string;
+  columnCount: number;
+  estimatedGridWidth: number;
+  isDynamic?: boolean;
+  fixedRowCount?: number;
+}
+
+const StaticSectionGrid = ({
+  sectionId,
+  board,
+  layoutId,
+  columnCount,
+  estimatedGridWidth,
+  isDynamic,
+  fixedRowCount,
+}: StaticSectionGridProps) => {
+  const allItems = getStaticGridElements(board, sectionId, layoutId);
+
+  if (allItems.length === 0) return null;
+
+  const rowCount = getStaticGridRowCount(allItems, fixedRowCount);
+
+  return (
+    <div className="static-grid-container" style={{ height: isDynamic ? "100%" : undefined }}>
+      <div
+        className="static-grid"
+        style={{
+          display: "grid",
+          gridTemplateColumns: `repeat(${columnCount}, 1fr)`,
+          gridTemplateRows: isDynamic
+            ? `repeat(${rowCount}, 1fr)`
+            : `repeat(${rowCount}, calc(100cqi / ${columnCount}))`,
+          height: isDynamic ? "100%" : undefined,
+        }}
+      >
+        {allItems.map((item) => (
+          <StaticGridItem
+            key={item.id}
+            item={item}
+            board={board}
+            layoutId={layoutId}
+            estimatedGridWidth={estimatedGridWidth}
+            columnCount={columnCount}
+          />
+        ))}
+      </div>
+    </div>
+  );
+};
+
+interface StaticGridItemProps {
+  item: SectionItem | DynamicSectionItem;
+  board: Board;
+  layoutId: string;
+  estimatedGridWidth: number;
+  columnCount: number;
+}
+
+const StaticGridItem = ({ item, board, layoutId, estimatedGridWidth, columnCount }: StaticGridItemProps) => {
+  const fallbackDimensions = getFallbackDimensions(item, estimatedGridWidth, columnCount);
+
+  return (
+    <div
+      style={{
+        gridColumn: `${item.xOffset + 1} / span ${item.width}`,
+        gridRow: `${item.yOffset + 1} / span ${item.height}`,
+        position: "relative",
+      }}
+    >
+      <div className="static-grid-item-content">
+        {item.type === "item" ? (
+          <BoardItemContent item={item} fallbackDimensions={fallbackDimensions} />
+        ) : (
+          <StaticDynamicSection
+            section={item}
+            board={board}
+            layoutId={layoutId}
+            estimatedGridWidth={fallbackDimensions.width}
+          />
+        )}
+      </div>
+    </div>
+  );
+};
+
+interface StaticEmptySectionProps {
+  section: EmptySection;
+  board: Board;
+  layoutId: string;
+  columnCount: number;
+  estimatedGridWidth: number;
+}
+
+const StaticEmptySection = ({ section, board, layoutId, columnCount, estimatedGridWidth }: StaticEmptySectionProps) => {
+  const items = getStaticGridElements(board, section.id, layoutId);
+
+  if (items.length === 0) return null;
+
+  return (
+    <StaticSectionGrid
+      sectionId={section.id}
+      board={board}
+      layoutId={layoutId}
+      columnCount={columnCount}
+      estimatedGridWidth={estimatedGridWidth}
+    />
+  );
+};
+
+interface StaticCategorySectionProps {
+  section: CategorySection;
+  board: Board;
+  layoutId: string;
+  columnCount: number;
+  estimatedGridWidth: number;
+}
+
+const StaticCategorySection = ({
+  section,
+  board,
+  layoutId,
+  columnCount,
+  estimatedGridWidth,
+}: StaticCategorySectionProps) => {
+  const boardData = useRequiredBoard();
+  const [opened, { toggle }] = useCategoryCollapse(section);
+
+  return (
+    <Card
+      style={{ "--opacity": boardData.opacity / 100 }}
+      radius={boardData.itemRadius}
+      p={0}
+      className={classes.itemCard}
+    >
+      <Stack>
+        <Group wrap="nowrap" gap="sm">
+          <UnstyledButton w="100%" p="sm" onClick={toggle}>
+            <Group wrap="nowrap">
+              {opened ? <IconChevronUp size={20} /> : <IconChevronDown size={20} />}
+              <Title order={3}>{section.name}</Title>
+            </Group>
+          </UnstyledButton>
+          <CategoryMenu category={section} />
+        </Group>
+        <Collapse expanded={opened} p="sm" pt={0}>
+          <StaticSectionGrid
+            sectionId={section.id}
+            board={board}
+            layoutId={layoutId}
+            columnCount={columnCount}
+            estimatedGridWidth={estimatedGridWidth}
+          />
+        </Collapse>
+      </Stack>
+    </Card>
+  );
+};
+
+interface StaticDynamicSectionProps {
+  section: DynamicSectionItem;
+  board: Board;
+  layoutId: string;
+  estimatedGridWidth: number;
+}
+
+const StaticDynamicSection = ({ section, board, layoutId, estimatedGridWidth }: StaticDynamicSectionProps) => {
+  const boardData = useRequiredBoard();
+  const options = section.options;
+
+  return (
+    <Card
+      className={classes.itemCard}
+      w="100%"
+      h="100%"
+      styles={{
+        root: {
+          overflow: "visible",
+          "--opacity": boardData.opacity / 100,
+          "--border-color": options.borderColor || undefined,
+        },
+      }}
+      radius={boardData.itemRadius}
+      p={0}
+    >
+      {options.title && (
+        <Badge
+          pos="absolute"
+          top={-15}
+          left={10}
+          size="md"
+          radius={boardData.itemRadius}
+          color="var(--background-color)"
+          c="var(--mantine-color-text)"
+          bd="1px solid var(--border-color)"
+        >
+          {options.title}
+        </Badge>
+      )}
+      <StaticSectionGrid
+        sectionId={section.id}
+        board={board}
+        layoutId={layoutId}
+        columnCount={section.width}
+        estimatedGridWidth={estimatedGridWidth}
+        isDynamic
+        fixedRowCount={section.height}
+      />
+    </Card>
+  );
+};

apps/nextjs/src/components/board/sections/use-category-collapse.ts

@@ -0,0 +1,77 @@
+"use client";
+
+import { useCallback, useEffect, useState } from "react";
+
+import { clientApi } from "@homarr/api/client";
+import { useSession } from "@homarr/auth/client";
+
+import type { CategorySection } from "~/app/[locale]/boards/_types";
+
+export const getCategoryCollapseStorageKey = (sectionId: string) => `homarr-section-collapsed-${sectionId}`;
+
+const categoryCollapseChangeEventName = "homarr-section-collapse-change";
+
+interface CategoryExpandedChangeEventDetail {
+  sectionId: string;
+  expanded: boolean;
+}
+
+const getInitialExpanded = (section: CategorySection) => {
+  if (typeof window === "undefined") return section.collapsed;
+
+  return (localStorage.getItem(getCategoryCollapseStorageKey(section.id)) ?? String(section.collapsed)) === "true";
+};
+
+export const useCategoryCollapse = (section: CategorySection) => {
+  const { status } = useSession();
+  const { mutate } = clientApi.section.changeCollapsed.useMutation();
+  const [opened, setOpened] = useState(() => getInitialExpanded(section));
+
+  const persistExpanded = useCallback(
+    (expanded: boolean) => {
+      if (status === "authenticated") {
+        mutate({ sectionId: section.id, collapsed: expanded });
+      } else if (status === "unauthenticated") {
+        localStorage.setItem(getCategoryCollapseStorageKey(section.id), String(expanded));
+      }
+    },
+    [mutate, section.id, status],
+  );
+
+  useEffect(() => {
+    const handleCollapseChange = (event: Event) => {
+      const { sectionId, expanded } = (event as CustomEvent<CategoryExpandedChangeEventDetail>).detail;
+      if (sectionId === section.id) {
+        setOpened(expanded);
+      }
+    };
+
+    window.addEventListener(categoryCollapseChangeEventName, handleCollapseChange);
+
+    return () => {
+      window.removeEventListener(categoryCollapseChangeEventName, handleCollapseChange);
+    };
+  }, [section.id]);
+
+  const toggle = useCallback(() => {
+    setOpened((current) => {
+      const expanded = !current;
+      persistExpanded(expanded);
+
+      if (typeof window !== "undefined") {
+        window.dispatchEvent(
+          new CustomEvent<CategoryExpandedChangeEventDetail>(categoryCollapseChangeEventName, {
+            detail: {
+              sectionId: section.id,
+              expanded,
+            },
+          }),
+        );
+      }
+
+      return expanded;
+    });
+  }, [persistExpanded, section.id]);
+
+  return [opened, { toggle }] as const;
+};

apps/nextjs/src/styles/gridstack.scss

@@ -112,3 +112,17 @@
 .grid-stack-empty-wrapper {
   display: none !important;
 }
+
+.static-grid-container {
+  container-type: inline-size;
+}
+
+.static-grid-item-content {
+  position: absolute;
+  inset: 10px;
+
+  > .grid-stack-item-content {
+    width: 100%;
+    height: 100%;
+  }
+}

e2e/board-responsive.spec.ts

@@ -0,0 +1,304 @@
+import { chromium } from "@playwright/test";
+import { createId } from "@paralleldrive/cuid2";
+import SuperJSON from "superjson";
+import { describe, expect, test } from "vitest";
+
+import * as sqliteSchema from "../packages/db/schema/sqlite";
+import { hashPasswordAsync } from "../packages/auth/security";
+import { createHomarrContainer } from "./shared/create-homarr-container";
+import { createSqliteDbFileAsync } from "./shared/e2e-db";
+import type { SqliteDatabase } from "./shared/e2e-db";
+
+const boardName = "responsive-board";
+const credentials = {
+  username: "responsive-admin",
+  password: "Comp(exP4sswOrd",
+};
+const viewports = [
+  { width: 320, height: 568 },
+  { width: 375, height: 667 },
+  { width: 768, height: 1024 },
+  { width: 1024, height: 768 },
+  { width: 1366, height: 768 },
+  { width: 1920, height: 1080 },
+];
+
+describe("Board responsive layout", () => {
+  test("renders static board layouts across common viewports and loads edit mode", async () => {
+    const { db, localMountPath } = await createSqliteDbFileAsync();
+    const { categorySectionId } = await seedResponsiveBoardAsync(db);
+    const homarrContainer = await createHomarrContainer({
+      mounts: {
+        "/appdata": localMountPath,
+      },
+    }).start();
+    const browser = await chromium.launch();
+    const baseUrl = `http://${homarrContainer.getHost()}:${homarrContainer.getMappedPort(7575)}`;
+
+    try {
+      for (const viewport of viewports) {
+        const context = await browser.newContext({ viewport });
+        await context.addInitScript(() => {
+          window.__homarrLayoutShiftScore = 0;
+          new PerformanceObserver((entries) => {
+            for (const entry of entries.getEntries()) {
+              const layoutShift = entry as PerformanceEntry & { value: number; hadRecentInput: boolean };
+              if (!layoutShift.hadRecentInput) {
+                window.__homarrLayoutShiftScore += layoutShift.value;
+              }
+            }
+          }).observe({ type: "layout-shift", buffered: true });
+        });
+        await context.addInitScript(
+          ({ sectionId }) => {
+            localStorage.setItem(`homarr-section-collapsed-${sectionId}`, "true");
+          },
+          { sectionId: categorySectionId },
+        );
+        const page = await context.newPage();
+
+        await page.goto(`${baseUrl}/boards/${boardName}`);
+        await page.waitForSelector(".static-grid-item-content", { state: "visible" });
+        await page.waitForTimeout(500);
+
+        const result = await page.evaluate(() => {
+          const visibleLayout = Array.from(document.querySelectorAll<HTMLElement>(".static-board-layout")).find(
+            (element) => getComputedStyle(element).display !== "none",
+          );
+          const grids = Array.from(visibleLayout?.querySelectorAll<HTMLElement>(".static-grid") ?? []);
+          const hasOverlappingItems = grids.some((grid) => {
+            const rects = Array.from(grid.children)
+              .map((element) => element.getBoundingClientRect())
+              .filter((rect) => rect.width > 0 && rect.height > 0);
+
+            return rects.some((rect, index) =>
+              rects.slice(index + 1).some((otherRect) => {
+                const horizontalOverlap = Math.min(rect.right, otherRect.right) - Math.max(rect.left, otherRect.left);
+                const verticalOverlap = Math.min(rect.bottom, otherRect.bottom) - Math.max(rect.top, otherRect.top);
+                return horizontalOverlap > 1 && verticalOverlap > 1;
+              }),
+            );
+          });
+          const visibleItems = Array.from(
+            visibleLayout?.querySelectorAll<HTMLElement>(".static-grid-item-content") ?? [],
+          ).filter((element) => {
+            const rect = element.getBoundingClientRect();
+            return rect.width > 0 && rect.height > 0;
+          });
+
+          return {
+            hasVisibleLayout: Boolean(visibleLayout),
+            visibleItemCount: visibleItems.length,
+            hasHorizontalOverflow: document.documentElement.scrollWidth > window.innerWidth + 1,
+            hasOverlappingItems,
+            layoutShiftScore: window.__homarrLayoutShiftScore,
+          };
+        });
+
+        expect(result.hasVisibleLayout).toBe(true);
+        expect(result.visibleItemCount).toBe(4);
+        expect(result.hasHorizontalOverflow).toBe(false);
+        expect(result.hasOverlappingItems).toBe(false);
+        expect(result.layoutShiftScore).toBeLessThanOrEqual(0.01);
+
+        await context.close();
+      }
+
+      const context = await browser.newContext({ viewport: { width: 1366, height: 768 } });
+      const page = await context.newPage();
+      await page.goto(`${baseUrl}/auth/login`);
+      await page.getByLabel("Username").fill(credentials.username);
+      await page.getByLabel("Password").fill(credentials.password);
+      await page.locator("css=button[type='submit']").click();
+      await page.waitForURL(baseUrl);
+      await page.goto(`${baseUrl}/boards/${boardName}`);
+      await page.waitForSelector(".static-grid-item-content", { state: "visible" });
+
+      await page.keyboard.press("ControlOrMeta+E");
+
+      await page.waitForSelector(".grid-stack", { state: "visible" });
+      await expect.poll(() => page.locator(".grid-stack-item").count()).toBeGreaterThan(0);
+      await context.close();
+    } finally {
+      await browser.close();
+      await homarrContainer.stop();
+    }
+  }, 120_000);
+});
+
+const seedResponsiveBoardAsync = async (db: SqliteDatabase) => {
+  const userId = createId();
+  const boardId = createId();
+  const mobileLayoutId = createId();
+  const tabletLayoutId = createId();
+  const desktopLayoutId = createId();
+  const rootSectionId = createId();
+  const categorySectionId = createId();
+  const dynamicSectionId = createId();
+
+  await db.update(sqliteSchema.onboarding).set({ step: "finish" });
+  await db.insert(sqliteSchema.users).values({
+    id: userId,
+    name: credentials.username,
+    password: await hashPasswordAsync(credentials.password),
+  });
+  await db.insert(sqliteSchema.boards).values({
+    id: boardId,
+    name: boardName,
+    isPublic: true,
+    creatorId: userId,
+  });
+  await db.insert(sqliteSchema.layouts).values([
+    { id: mobileLayoutId, name: "Mobile", boardId, columnCount: 4, breakpoint: 0 },
+    { id: tabletLayoutId, name: "Tablet", boardId, columnCount: 8, breakpoint: 768 },
+    { id: desktopLayoutId, name: "Desktop", boardId, columnCount: 12, breakpoint: 1024 },
+  ]);
+  await db.insert(sqliteSchema.sections).values([
+    { id: rootSectionId, boardId, kind: "empty", xOffset: 0, yOffset: 0 },
+    { id: categorySectionId, boardId, kind: "category", xOffset: 0, yOffset: 1, name: "Systems" },
+    {
+      id: dynamicSectionId,
+      boardId,
+      kind: "dynamic",
+      options: SuperJSON.stringify({ title: "Nested", borderColor: "", customCssClasses: [] }),
+    },
+  ]);
+  await db.insert(sqliteSchema.sectionLayouts).values([
+    {
+      sectionId: dynamicSectionId,
+      layoutId: mobileLayoutId,
+      parentSectionId: categorySectionId,
+      xOffset: 0,
+      yOffset: 0,
+      width: 4,
+      height: 2,
+    },
+    {
+      sectionId: dynamicSectionId,
+      layoutId: tabletLayoutId,
+      parentSectionId: categorySectionId,
+      xOffset: 0,
+      yOffset: 0,
+      width: 4,
+      height: 2,
+    },
+    {
+      sectionId: dynamicSectionId,
+      layoutId: desktopLayoutId,
+      parentSectionId: categorySectionId,
+      xOffset: 0,
+      yOffset: 0,
+      width: 6,
+      height: 2,
+    },
+  ]);
+
+  const rootItemId = await insertClockItemAsync(db, boardId);
+  const categoryItemId = await insertClockItemAsync(db, boardId);
+  const dynamicItemId = await insertClockItemAsync(db, boardId);
+  await db.insert(sqliteSchema.itemLayouts).values([
+    {
+      itemId: rootItemId,
+      sectionId: rootSectionId,
+      layoutId: mobileLayoutId,
+      xOffset: 0,
+      yOffset: 0,
+      width: 2,
+      height: 1,
+    },
+    {
+      itemId: rootItemId,
+      sectionId: rootSectionId,
+      layoutId: tabletLayoutId,
+      xOffset: 0,
+      yOffset: 0,
+      width: 3,
+      height: 1,
+    },
+    {
+      itemId: rootItemId,
+      sectionId: rootSectionId,
+      layoutId: desktopLayoutId,
+      xOffset: 0,
+      yOffset: 0,
+      width: 4,
+      height: 1,
+    },
+    {
+      itemId: categoryItemId,
+      sectionId: categorySectionId,
+      layoutId: mobileLayoutId,
+      xOffset: 0,
+      yOffset: 2,
+      width: 4,
+      height: 1,
+    },
+    {
+      itemId: categoryItemId,
+      sectionId: categorySectionId,
+      layoutId: tabletLayoutId,
+      xOffset: 4,
+      yOffset: 0,
+      width: 4,
+      height: 2,
+    },
+    {
+      itemId: categoryItemId,
+      sectionId: categorySectionId,
+      layoutId: desktopLayoutId,
+      xOffset: 6,
+      yOffset: 0,
+      width: 6,
+      height: 2,
+    },
+    {
+      itemId: dynamicItemId,
+      sectionId: dynamicSectionId,
+      layoutId: mobileLayoutId,
+      xOffset: 0,
+      yOffset: 0,
+      width: 2,
+      height: 1,
+    },
+    {
+      itemId: dynamicItemId,
+      sectionId: dynamicSectionId,
+      layoutId: tabletLayoutId,
+      xOffset: 0,
+      yOffset: 0,
+      width: 2,
+      height: 1,
+    },
+    {
+      itemId: dynamicItemId,
+      sectionId: dynamicSectionId,
+      layoutId: desktopLayoutId,
+      xOffset: 0,
+      yOffset: 0,
+      width: 3,
+      height: 1,
+    },
+  ]);
+
+  return {
+    categorySectionId,
+  };
+};
+
+const insertClockItemAsync = async (db: SqliteDatabase, boardId: string) => {
+  const itemId = createId();
+  await db.insert(sqliteSchema.items).values({
+    id: itemId,
+    boardId,
+    kind: "clock",
+    options: SuperJSON.stringify({ is24HourFormat: true }),
+    advancedOptions: SuperJSON.stringify({ title: null, customCssClasses: [], borderColor: "" }),
+  });
+  return itemId;
+};
+
+declare global {
+  interface Window {
+    __homarrLayoutShiftScore: number;
+  }
+}

packages/api/src/router/integration/integration-router.ts

@@ -1,8 +1,6 @@
 import { TRPCError } from "@trpc/server";
 import { z } from "zod/v4";
 
-import { hasQueryAccessToIntegrationsAsync } from "@homarr/auth/server";
-import { constructIntegrationPermissions } from "@homarr/auth/shared";
 import { createId, objectEntries } from "@homarr/common";
 import { decryptSecret, encryptSecret } from "@homarr/common/server";
 import { createLogger } from "@homarr/core/infrastructure/logs";
@@ -16,9 +14,11 @@ import {
   integrations,
   integrationSecrets,
   integrationUserPermissions,
+  searchEngines,
 } from "@homarr/db/schema";
 import type { IntegrationSecretKind } from "@homarr/definitions";
 import {
+  getIconUrl,
   getIntegrationKindsByCategory,
   getPermissionsWithParents,
   integrationCategories,
@@ -33,7 +33,6 @@ import {
   integrationSavePermissionsSchema,
   integrationUpdateSchema,
 } from "@homarr/validation/integration";
-import { mediaRequestOptionsSchema, mediaRequestRequestSchema } from "@homarr/validation/widgets/media-request";
 
 import { createOneIntegrationMiddleware } from "../../middlewares/integration";
 import { createTRPCRouter, permissionRequiredProcedure, protectedProcedure, publicProcedure } from "../../trpc";
@@ -42,7 +41,6 @@ import { MissingSecretError, testConnectionAsync } from "./integration-test-conn
 import { mapTestConnectionError } from "./map-test-connection-error";
 
 const logger = createLogger({ module: "integrationRouter" });
-const mediaRequestSearchKinds = getIntegrationKindsByCategory("mediaSearch");
 
 export const integrationRouter = createTRPCRouter({
   all: protectedProcedure.query(async ({ ctx }) => {
@@ -82,7 +80,7 @@ export const integrationRouter = createTRPCRouter({
           },
         };
       })
-      .toSorted(
+      .sort(
         (integrationA, integrationB) =>
           integrationKinds.indexOf(integrationA.kind) - integrationKinds.indexOf(integrationB.kind),
       );
@@ -130,7 +128,7 @@ export const integrationRouter = createTRPCRouter({
           },
         };
       })
-      .toSorted(
+      .sort(
         (integrationA, integrationB) =>
           integrationKinds.indexOf(integrationA.kind) - integrationKinds.indexOf(integrationB.kind),
       );
@@ -181,7 +179,7 @@ export const integrationRouter = createTRPCRouter({
             },
           };
         })
-        .toSorted(
+        .sort(
           (integrationA, integrationB) =>
             integrationKinds.indexOf(integrationA.kind) - integrationKinds.indexOf(integrationB.kind),
         );
@@ -316,7 +314,20 @@ export const integrationRouter = createTRPCRouter({
         url: input.url,
       });
 
-      // Media request search is a first-class Spotlight action. Do not create a search engine for it.
+      if (
+        input.attemptSearchEngineCreation &&
+        integrationDefs[input.kind].category.flatMap((category) => category).includes("search")
+      ) {
+        const icon = getIconUrl(input.kind);
+        await ctx.db.insert(searchEngines).values({
+          id: createId(),
+          name: input.name,
+          integrationId,
+          type: "fromIntegration",
+          iconUrl: icon,
+          short: await getNextValidShortNameForSearchEngineAsync(ctx.db, input.name),
+        });
+      }
     }),
   update: protectedProcedure.input(integrationUpdateSchema).mutation(async ({ ctx, input }) => {
     await throwIfActionForbiddenAsync(ctx, eq(integrations.id, input.id), "full");
@@ -484,7 +495,7 @@ export const integrationRouter = createTRPCRouter({
     });
 
     return {
-      inherited: dbGroupPermissions.toSorted((permissionA, permissionB) => {
+      inherited: dbGroupPermissions.sort((permissionA, permissionB) => {
         return permissionA.group.name.localeCompare(permissionB.group.name);
       }),
       users: userPermissions
@@ -492,7 +503,7 @@ export const integrationRouter = createTRPCRouter({
           user,
           permission,
         }))
-        .toSorted((permissionA, permissionB) => {
+        .sort((permissionA, permissionB) => {
           return (permissionA.user.name ?? "").localeCompare(permissionB.user.name ?? "");
         }),
       groups: dbGroupIntegrationPermission
@@ -503,7 +514,7 @@ export const integrationRouter = createTRPCRouter({
           },
           permission,
         }))
-        .toSorted((permissionA, permissionB) => {
+        .sort((permissionA, permissionB) => {
           return permissionA.group.name.localeCompare(permissionB.group.name);
         }),
     };
@@ -607,149 +618,8 @@ export const integrationRouter = createTRPCRouter({
       const integrationInstance = await createIntegrationAsync(ctx.integration);
       return await integrationInstance.searchAsync(encodeURI(input.query));
     }),
-  mediaRequestSearchTargets: protectedProcedure.query(async ({ ctx }) => {
-    const integrationsWithAccess = await getAccessibleMediaRequestSearchIntegrationsAsync(ctx);
-
-    return integrationsWithAccess.map((integration) => {
-      const permissions = constructIntegrationPermissions(integration, ctx.session);
-
-      return {
-        id: integration.id,
-        name: integration.name,
-        kind: integration.kind,
-        url: integration.url,
-        permissions: {
-          hasInteractAccess: permissions.hasInteractAccess,
-        },
-      };
-    });
-  }),
-  searchMediaRequests: protectedProcedure
-    .input(
-      z.object({
-        query: z.string(),
-        integrationIds: z.array(z.string()).optional(),
-      }),
-    )
-    .query(async ({ ctx, input }) => {
-      const query = input.query.trim();
-      if (query.length === 0) return [];
-
-      const integrationsWithAccess = await getAccessibleMediaRequestSearchIntegrationsAsync(ctx, input.integrationIds);
-
-      const results = await Promise.all(
-        integrationsWithAccess.map(async (integration) => {
-          const integrationInstance = await createIntegrationAsync({
-            id: integration.id,
-            name: integration.name,
-            url: integration.url,
-            kind: integration.kind as (typeof mediaRequestSearchKinds)[number],
-            externalUrl: integration.app?.href ?? null,
-            decryptedSecrets: integration.secrets.map((secret) => ({
-              ...secret,
-              value: decryptSecret(secret.value),
-            })),
-          });
-          const permissions = constructIntegrationPermissions(integration, ctx.session);
-
-          return await integrationInstance.searchAsync(encodeURI(query)).then((searchResults) =>
-            searchResults.map((result) => ({
-              ...result,
-              integration: {
-                id: integration.id,
-                name: integration.name,
-                kind: integration.kind,
-                url: integration.url,
-                permissions: {
-                  hasInteractAccess: permissions.hasInteractAccess,
-                },
-              },
-            })),
-          );
-        }),
-      );
-
-      return results.flat();
-    }),
-  getMediaRequestOptions: protectedProcedure
-    .concat(createOneIntegrationMiddleware("query", "jellyseerr", "overseerr", "seerr"))
-    .input(mediaRequestOptionsSchema)
-    .query(async ({ ctx, input }) => {
-      const integration = await createIntegrationAsync(ctx.integration);
-      return await integration.getSeriesInformationAsync(input.mediaType, input.mediaId);
-    }),
-  requestMedia: protectedProcedure
-    .concat(createOneIntegrationMiddleware("interact", "jellyseerr", "overseerr", "seerr"))
-    .input(mediaRequestRequestSchema)
-    .mutation(async ({ ctx, input }) => {
-      const integration = await createIntegrationAsync(ctx.integration);
-      return await integration.requestMediaAsync(input.mediaType, input.mediaId, input.seasons);
-    }),
 });
 
-interface IntegrationRouterContext {
-  db: Database;
-  session: Parameters<typeof hasQueryAccessToIntegrationsAsync>[2];
-}
-
-const getAccessibleMediaRequestSearchIntegrationsAsync = async (
-  ctx: IntegrationRouterContext,
-  integrationIds?: string[],
-) => {
-  const groupsOfCurrentUser = await ctx.db.query.groupMembers.findMany({
-    where: eq(groupMembers.userId, ctx.session?.user.id ?? ""),
-  });
-
-  const integrationsFromDb = await ctx.db.query.integrations.findMany({
-    where:
-      integrationIds && integrationIds.length > 0
-        ? and(inArray(integrations.id, integrationIds), inArray(integrations.kind, mediaRequestSearchKinds))
-        : inArray(integrations.kind, mediaRequestSearchKinds),
-    orderBy: asc(integrations.name),
-    with: {
-      app: true,
-      secrets: true,
-      items: {
-        with: {
-          item: true,
-        },
-      },
-      userPermissions: {
-        where: eq(integrationUserPermissions.userId, ctx.session?.user.id ?? ""),
-      },
-      groupPermissions: {
-        where: inArray(
-          integrationGroupPermissions.groupId,
-          groupsOfCurrentUser.map((group) => group.groupId),
-        ),
-      },
-    },
-  });
-
-  if (integrationIds && integrationsFromDb.length !== integrationIds.length) {
-    throw new TRPCError({
-      code: "NOT_FOUND",
-      message: "One or more media request search integrations were not found",
-    });
-  }
-
-  const integrationsWithAccess = await Promise.all(
-    integrationsFromDb.map(async (integration) => ({
-      integration,
-      hasAccess: await hasQueryAccessToIntegrationsAsync(ctx.db, [integration], ctx.session),
-    })),
-  );
-
-  if (integrationIds && integrationsWithAccess.some(({ hasAccess }) => !hasAccess)) {
-    throw new TRPCError({
-      code: "FORBIDDEN",
-      message: "User does not have permission to query one or more media request search integrations",
-    });
-  }
-
-  return integrationsWithAccess.filter(({ hasAccess }) => hasAccess).map(({ integration }) => integration);
-};
-
 interface UpdateSecretInput {
   integrationId: string;
   value: string;
@@ -770,6 +640,35 @@ interface AddSecretInput {
   kind: IntegrationSecretKind;
 }
 
+const getNextValidShortNameForSearchEngineAsync = async (db: Database, integrationName: string) => {
+  const searchEngines = await db.query.searchEngines.findMany({
+    columns: {
+      short: true,
+    },
+  });
+
+  const usedShortNames = searchEngines.flatMap((searchEngine) => searchEngine.short.toLowerCase());
+  const nameByIntegrationName = integrationName.slice(0, 1).toLowerCase();
+
+  if (!usedShortNames.includes(nameByIntegrationName)) {
+    return nameByIntegrationName;
+  }
+
+  // 8 is max length constraint
+  for (let i = 2; i < 9999999; i++) {
+    const generatedName = `${nameByIntegrationName}${i}`;
+    if (usedShortNames.includes(generatedName)) {
+      continue;
+    }
+
+    return generatedName;
+  }
+
+  throw new Error(
+    "Unable to automatically generate a short name. All possible variations were exhausted. Please disable the automatic creation and choose one later yourself.",
+  );
+};
+
 const addSecretAsync = async (db: Database, input: AddSecretInput) => {
   await db.insert(integrationSecrets).values({
     kind: input.kind,

packages/api/src/router/search-engine/search-engine-router.ts

@@ -6,9 +6,12 @@ import { createLogger } from "@homarr/core/infrastructure/logs";
 import { asc, eq, like } from "@homarr/db";
 import { getServerSettingByKeyAsync, updateServerSettingByKeyAsync } from "@homarr/db/queries";
 import { searchEngines, users } from "@homarr/db/schema";
+import { createIntegrationAsync } from "@homarr/integrations";
 import { byIdSchema, paginatedSchema, searchSchema } from "@homarr/validation/common";
 import { searchEngineEditSchema, searchEngineManageSchema } from "@homarr/validation/search-engine";
+import { mediaRequestOptionsSchema, mediaRequestRequestSchema } from "@homarr/validation/widgets/media-request";
 
+import { createOneIntegrationMiddleware } from "../../middlewares/integration";
 import { createTRPCRouter, permissionRequiredProcedure, protectedProcedure, publicProcedure } from "../../trpc";
 
 const logger = createLogger({ module: "searchEngineRouter" });
@@ -145,6 +148,20 @@ export const searchEngineRouter = createTRPCRouter({
       limit: input.limit,
     });
   }),
+  getMediaRequestOptions: protectedProcedure
+    .concat(createOneIntegrationMiddleware("query", "jellyseerr", "overseerr"))
+    .input(mediaRequestOptionsSchema)
+    .query(async ({ ctx, input }) => {
+      const integration = await createIntegrationAsync(ctx.integration);
+      return await integration.getSeriesInformationAsync(input.mediaType, input.mediaId);
+    }),
+  requestMedia: protectedProcedure
+    .concat(createOneIntegrationMiddleware("interact", "jellyseerr", "overseerr"))
+    .input(mediaRequestRequestSchema)
+    .mutation(async ({ ctx, input }) => {
+      const integration = await createIntegrationAsync(ctx.integration);
+      return await integration.requestMediaAsync(input.mediaType, input.mediaId, input.seasons);
+    }),
   create: permissionRequiredProcedure
     .requiresPermission("search-engine-create")
     .input(searchEngineManageSchema)

packages/api/src/router/test/integration/integration-router.spec.ts

@@ -4,7 +4,7 @@ import { describe, expect, test, vi } from "vitest";
 import type { Session } from "@homarr/auth";
 import { createId } from "@homarr/common";
 import { encryptSecret } from "@homarr/common/server";
-import { apps, integrations, integrationSecrets, integrationUserPermissions, users } from "@homarr/db/schema";
+import { apps, integrations, integrationSecrets } from "@homarr/db/schema";
 import { createDb } from "@homarr/db/test";
 import type { GroupPermissionKey } from "@homarr/definitions";
 
@@ -59,127 +59,6 @@ describe("all should return all integrations", () => {
   });
 });
 
-describe("mediaRequestSearchTargets should return accessible media search integrations", () => {
-  test("with integration use access should only return media request search integrations", async () => {
-    const db = createDb();
-    const caller = integrationRouter.createCaller({
-      db,
-      deviceType: undefined,
-      session: defaultSessionWithPermissions(["integration-use-all"]),
-    });
-
-    await db.insert(integrations).values([
-      {
-        id: "1",
-        name: "Jellyseerr",
-        kind: "jellyseerr",
-        url: "http://jellyseerr.local",
-      },
-      {
-        id: "2",
-        name: "Jellyfin",
-        kind: "jellyfin",
-        url: "http://jellyfin.local",
-      },
-    ]);
-
-    const result = await caller.mediaRequestSearchTargets();
-
-    expect(result).toHaveLength(1);
-    expect(result[0]!.id).toBe("1");
-    expect(result[0]!.kind).toBe("jellyseerr");
-  });
-
-  test("without access should not return media request search integrations", async () => {
-    const db = createDb();
-    const caller = integrationRouter.createCaller({
-      db,
-      deviceType: undefined,
-      session: defaultSessionWithPermissions(),
-    });
-
-    await db.insert(integrations).values({
-      id: "1",
-      name: "Jellyseerr",
-      kind: "jellyseerr",
-      url: "http://jellyseerr.local",
-    });
-
-    const result = await caller.mediaRequestSearchTargets();
-
-    expect(result).toHaveLength(0);
-  });
-
-  test("with direct integration use access should return media request search integrations", async () => {
-    const db = createDb();
-    const caller = integrationRouter.createCaller({
-      db,
-      deviceType: undefined,
-      session: defaultSessionWithPermissions(),
-    });
-
-    await db.insert(integrations).values({
-      id: "1",
-      name: "Jellyseerr",
-      kind: "jellyseerr",
-      url: "http://jellyseerr.local",
-    });
-    await db.insert(users).values({ id: defaultUserId });
-    await db.insert(integrationUserPermissions).values({
-      integrationId: "1",
-      userId: defaultUserId,
-      permission: "use",
-    });
-
-    const result = await caller.mediaRequestSearchTargets();
-
-    expect(result).toHaveLength(1);
-    expect(result[0]!.id).toBe("1");
-  });
-});
-
-describe("searchMediaRequests should validate scoped integrations", () => {
-  test("with a non media search integration should throw not found", async () => {
-    const db = createDb();
-    const caller = integrationRouter.createCaller({
-      db,
-      deviceType: undefined,
-      session: defaultSessionWithPermissions(["integration-use-all"]),
-    });
-
-    await db.insert(integrations).values({
-      id: "1",
-      name: "Jellyfin",
-      kind: "jellyfin",
-      url: "http://jellyfin.local",
-    });
-
-    await expect(caller.searchMediaRequests({ query: "matrix", integrationIds: ["1"] })).rejects.toThrow(
-      "One or more media request search integrations were not found",
-    );
-  });
-
-  test("without query access to a scoped media search integration should throw forbidden", async () => {
-    const db = createDb();
-    const caller = integrationRouter.createCaller({
-      db,
-      deviceType: undefined,
-      session: defaultSessionWithPermissions(),
-    });
-
-    await db.insert(integrations).values({
-      id: "1",
-      name: "Jellyseerr",
-      kind: "jellyseerr",
-      url: "http://jellyseerr.local",
-    });
-
-    await expect(caller.searchMediaRequests({ query: "matrix", integrationIds: ["1"] })).rejects.toThrow(
-      "User does not have permission to query one or more media request search integrations",
-    );
-  });
-});
-
 describe("byId should return an integration by id", () => {
   test("with full access should return an integration by id", async () => {
     const db = createDb();
@@ -329,7 +208,7 @@ describe("create should create a new integration", () => {
     expect(dbSecret!.updatedAt).toEqual(fakeNow);
   });
 
-  test("with create integration access should not create a search engine for media request search integrations", async () => {
+  test("with create integration access should create a new integration when creating search engine", async () => {
     const db = createDb();
     const caller = integrationRouter.createCaller({
       db,
@@ -364,7 +243,12 @@ describe("create should create a new integration", () => {
     expect(dbSecret!.value).toMatch(/^[a-f0-9]+.[a-f0-9]+$/);
     expect(dbSecret!.updatedAt).toEqual(fakeNow);
 
-    expect(dbSearchEngine).toBeUndefined();
+    expect(dbSearchEngine!.integrationId).toBe(dbIntegration!.id);
+    expect(dbSearchEngine!.short).toBe("j");
+    expect(dbSearchEngine!.name).toBe(input.name);
+    expect(dbSearchEngine!.iconUrl).toBe(
+      "https://cdn.jsdelivr.net/gh/homarr-labs/dashboard-icons@master/svg/jellyseerr.svg",
+    );
   });
 
   test("with create integration access should create a new integration with new linked app", async () => {

packages/api/src/router/user.ts

@@ -542,7 +542,7 @@ export const userRouter = createTRPCRouter({
         .set({
           pingIconsEnabled: input.pingIconsEnabled,
         })
-        .where(eq(users.id, input.id));
+        .where(eq(users.id, ctx.session.user.id));
     }),
   changeDdgBangs: protectedProcedure
     .input(convertIntersectionToZodObject(userDdgBangsSchema.and(byIdSchema)))
@@ -603,7 +603,7 @@ export const userRouter = createTRPCRouter({
         .set({
           firstDayOfWeek: input.firstDayOfWeek,
         })
-        .where(eq(users.id, input.id));
+        .where(eq(users.id, ctx.session.user.id));
     }),
 });
 

packages/forms-collection/src/new-app/_form.tsx

@@ -1,7 +1,7 @@
 "use client";
 
 import type { ChangeEventHandler } from "react";
-import { useEffect, useImperativeHandle, useRef } from "react";
+import { useEffect, useRef } from "react";
 import { Button, Checkbox, Collapse, Group, Stack, Textarea, TextInput } from "@mantine/core";
 import { useDebouncedValue, useDisclosure } from "@mantine/hooks";
 import type { z } from "zod/v4";
@@ -17,19 +17,6 @@ import { findBestIconMatch } from "./icon-matcher";
 
 type FormType = z.infer<typeof appManageSchema>;
 
-const toFormValues = (values: FormType | undefined): FormType => ({
-  name: values?.name ?? "",
-  description: values?.description ?? "",
-  iconUrl: values?.iconUrl ?? "",
-  href: values?.href ?? "",
-  pingUrl: values?.pingUrl ?? "",
-});
-
-export interface AppFormHandle {
-  submit: () => Promise<boolean>;
-  isDirty: () => boolean;
-}
-
 interface AppFormProps {
   showBackToOverview: boolean;
   buttonLabels: {
@@ -37,10 +24,8 @@ interface AppFormProps {
     submitAndCreateAnother?: string;
   };
   initialValues?: FormType;
-  handleSubmit: (values: FormType, redirect: boolean, afterSuccess?: () => void) => void | Promise<void>;
+  handleSubmit: (values: FormType, redirect: boolean, afterSuccess?: () => void) => void;
   isPending: boolean;
-  hideButtons?: boolean;
-  formRef?: React.Ref<AppFormHandle>;
 }
 
 export const AppForm = ({
@@ -49,31 +34,19 @@ export const AppForm = ({
   handleSubmit: originalHandleSubmit,
   initialValues,
   isPending,
-  hideButtons,
-  formRef,
 }: AppFormProps) => {
   const t = useI18n();
 
   const form = useZodForm(appManageSchema, {
-    initialValues: toFormValues(initialValues),
+    initialValues: {
+      name: initialValues?.name ?? "",
+      description: initialValues?.description ?? "",
+      iconUrl: initialValues?.iconUrl ?? "",
+      href: initialValues?.href ?? "",
+      pingUrl: initialValues?.pingUrl ?? "",
+    },
   });
 
-  const initialValuesKey = [
-    initialValues?.name,
-    initialValues?.description,
-    initialValues?.iconUrl,
-    initialValues?.href,
-    initialValues?.pingUrl,
-  ].join("\0");
-
-  useEffect(() => {
-    if (!initialValues || form.isDirty()) {
-      return;
-    }
-
-    form.initialize(toFormValues(initialValues));
-  }, [initialValuesKey, form, initialValues]);
-
   // Debounce the name value with 200ms delay
   const [debouncedName] = useDebouncedValue(form.values.name, 200);
 
@@ -89,29 +62,6 @@ export const AppForm = ({
     originalHandleSubmit(values, redirect, afterSuccess);
   };
 
-  useImperativeHandle(
-    formRef,
-    () => ({
-      submit: () =>
-        new Promise<boolean>((resolve) => {
-          form.onSubmit(
-            async (values) => {
-              try {
-                await Promise.resolve(handleSubmit(values));
-                form.initialize(values);
-                resolve(true);
-              } catch {
-                resolve(false);
-              }
-            },
-            () => resolve(false),
-          )();
-        }),
-      isDirty: () => form.isDirty(),
-    }),
-    [form, handleSubmit],
-  );
-
   const [opened, { open, close }] = useDisclosure((initialValues?.pingUrl?.length ?? 0) > 0);
 
   const handleClickDifferentUrlPing: ChangeEventHandler<HTMLInputElement> = () => {
@@ -142,32 +92,32 @@ export const AppForm = ({
     }
   }, [debouncedName, iconsData]);
 
-  const formFields = (
-    <Stack>
-      <TextInput {...form.getInputProps("name")} withAsterisk label={t("app.field.name.label")} />
-      <IconPicker {...form.getInputProps("iconUrl")} />
-      <Textarea
-        {...form.getInputProps("description")}
-        label={t("app.field.description.label")}
-        autosize
-        minRows={2}
-        resize="vertical"
-      />
-      <TextInput {...form.getInputProps("href")} label={t("app.field.url.label")} />
+  return (
+    <form onSubmit={form.onSubmit(handleSubmit)}>
+      <Stack>
+        <TextInput {...form.getInputProps("name")} withAsterisk label={t("app.field.name.label")} />
+        <IconPicker {...form.getInputProps("iconUrl")} />
+        <Textarea
+          {...form.getInputProps("description")}
+          label={t("app.field.description.label")}
+          autosize
+          minRows={2}
+          resize="vertical"
+        />
+        <TextInput {...form.getInputProps("href")} label={t("app.field.url.label")} />
 
-      <Checkbox
-        checked={opened}
-        onChange={handleClickDifferentUrlPing}
-        label={t("app.field.useDifferentUrlForPing.checkbox.label")}
-        description={t("app.field.useDifferentUrlForPing.checkbox.description")}
-        mt="md"
-      />
+        <Checkbox
+          checked={opened}
+          onChange={handleClickDifferentUrlPing}
+          label={t("app.field.useDifferentUrlForPing.checkbox.label")}
+          description={t("app.field.useDifferentUrlForPing.checkbox.description")}
+          mt="md"
+        />
 
-      <Collapse expanded={opened}>
-        <TextInput {...form.getInputProps("pingUrl")} />
-      </Collapse>
+        <Collapse expanded={opened}>
+          <TextInput {...form.getInputProps("pingUrl")} />
+        </Collapse>
 
-      {!hideButtons && (
         <Group justify="end">
           {showBackToOverview && (
             <Button variant="default" component={Link} href="/manage/apps">
@@ -189,13 +139,7 @@ export const AppForm = ({
             {buttonLabels.submit}
           </Button>
         </Group>
-      )}
-    </Stack>
+      </Stack>
+    </form>
   );
-
-  if (hideButtons) {
-    return formFields;
-  }
-
-  return <form onSubmit={form.onSubmit(handleSubmit)}>{formFields}</form>;
 };

packages/integrations/src/interfaces/media-requests/media-request-types.ts

@@ -12,14 +12,12 @@ interface SeriesInformation {
   overview: string;
   seasons: SerieSeason[];
   posterPath: string;
-  requestedSeasons?: number[];
 }
 
 interface MovieInformation {
   id: number;
   overview: string;
   posterPath: string;
-  requestedSeasons?: number[];
 }
 
 export type MediaInformation = SeriesInformation | MovieInformation;

packages/integrations/src/overseerr/overseerr-integration.ts

@@ -60,9 +60,6 @@ export class OverseerrIntegration
       text: "overview" in result ? result.overview : undefined,
       type: result.mediaType,
       inLibrary: result.mediaInfo !== undefined,
-      availability: result.mediaInfo
-        ? this.mapAvailability(result.mediaInfo.status as UpstreamMediaAvailability, false)
-        : undefined,
     }));
   }
 
@@ -73,12 +70,7 @@ export class OverseerrIntegration
         "X-Api-Key": this.getSecretValue("apiKey"),
       },
     });
-    const data = await mediaInformationSchema.parseAsync(await response.json());
-    const requestedSeasons = [
-      ...new Set(data.mediaInfo?.requests?.flatMap((req) => req.seasons.map((s) => s.seasonNumber)) ?? []),
-    ];
-    const { mediaInfo: _strip, ...rest } = data;
-    return { ...rest, requestedSeasons };
+    return await mediaInformationSchema.parseAsync(await response.json());
   }
 
   /**
@@ -349,22 +341,6 @@ interface MovieInformation {
   releaseDate: string;
 }
 
-const mediaInfoRequestsSchema = z
-  .object({
-    requests: z
-      .array(
-        z.object({
-          seasons: z.array(
-            z.object({
-              seasonNumber: z.number(),
-            }),
-          ),
-        }),
-      )
-      .optional(),
-  })
-  .optional();
-
 const mediaInformationSchema = z.union([
   z.object({
     id: z.number(),
@@ -379,22 +355,14 @@ const mediaInformationSchema = z.union([
     ),
     numberOfSeasons: z.number(),
     posterPath: z.string().startsWith("/"),
-    mediaInfo: mediaInfoRequestsSchema,
   }),
   z.object({
     id: z.number(),
     overview: z.string(),
     posterPath: z.string().startsWith("/"),
-    mediaInfo: mediaInfoRequestsSchema,
   }),
 ]);
 
-const searchMediaInfoSchema = z
-  .object({
-    status: z.number(),
-  })
-  .optional();
-
 const searchSchema = z.object({
   results: z
     .array(
@@ -405,7 +373,7 @@ const searchSchema = z.object({
           name: z.string(),
           posterPath: z.string().startsWith("/").endsWith(".jpg").nullable(),
           overview: z.string(),
-          mediaInfo: searchMediaInfoSchema,
+          mediaInfo: z.object({}).optional(),
         }),
         z.object({
           id: z.number(),
@@ -413,14 +381,14 @@ const searchSchema = z.object({
           title: z.string(),
           posterPath: z.string().startsWith("/").endsWith(".jpg").nullable(),
           overview: z.string(),
-          mediaInfo: searchMediaInfoSchema,
+          mediaInfo: z.object({}).optional(),
         }),
         z.object({
           id: z.number(),
           mediaType: z.literal("person"),
           name: z.string(),
           profilePath: z.string().startsWith("/").endsWith(".jpg").nullable(),
-          mediaInfo: searchMediaInfoSchema,
+          mediaInfo: z.object({}).optional(),
         }),
       ]),
     )

packages/modals-collection/src/search-engines/request-media-modal.tsx

@@ -1,6 +1,6 @@
 import { useMemo } from "react";
-import { Badge, Button, Group, Image, LoadingOverlay, Stack, Text } from "@mantine/core";
-import type { MRT_ColumnDef, MRT_Row } from "mantine-react-table";
+import { Button, Group, Image, LoadingOverlay, Stack, Text } from "@mantine/core";
+import type { MRT_ColumnDef } from "mantine-react-table";
 import { MRT_Table } from "mantine-react-table";
 
 import { clientApi } from "@homarr/api/client";
@@ -16,13 +16,13 @@ interface RequestMediaModalProps {
 }
 
 export const RequestMediaModal = createModal<RequestMediaModalProps>(({ actions, innerProps }) => {
-  const { data, isPending: isPendingQuery } = clientApi.integration.getMediaRequestOptions.useQuery({
+  const { data, isPending: isPendingQuery } = clientApi.searchEngine.getMediaRequestOptions.useQuery({
     integrationId: innerProps.integrationId,
     mediaId: innerProps.mediaId,
     mediaType: innerProps.mediaType,
   });
 
-  const { mutate, isPending: isPendingMutation } = clientApi.integration.requestMedia.useMutation({
+  const { mutate, isPending: isPendingMutation } = clientApi.searchEngine.requestMedia.useMutation({
     onSuccess() {
       actions.closeModal();
       showSuccessNotification({
@@ -33,7 +33,6 @@ export const RequestMediaModal = createModal<RequestMediaModalProps>(({ actions,
 
   const isPending = isPendingQuery || isPendingMutation;
   const t = useI18n();
-  const requestedSeasons = new Set(data?.requestedSeasons ?? []);
 
   const columns = useMemo<MRT_ColumnDef<Season>[]>(
     () => [
@@ -45,18 +44,8 @@ export const RequestMediaModal = createModal<RequestMediaModalProps>(({ actions,
         accessorKey: "episodeCount",
         header: t("search.engine.media.request.modal.table.header.episodes"),
       },
-      {
-        id: "status",
-        header: t("search.engine.media.request.modal.table.header.status"),
-        Cell: ({ row }) =>
-          requestedSeasons.has(row.original.seasonNumber) ? (
-            <Badge size="xs" color="violet" variant="light">
-              {t("search.engine.media.request.modal.table.status.requested")}
-            </Badge>
-          ) : null,
-      },
     ],
-    [data?.requestedSeasons],
+    [],
   );
 
   const table = useTranslatedMantineReactTable({
@@ -67,7 +56,7 @@ export const RequestMediaModal = createModal<RequestMediaModalProps>(({ actions,
     enablePagination: false,
     enableSorting: false,
     enableSelectAll: true,
-    enableRowSelection: (row: MRT_Row<Season>) => !requestedSeasons.has(row.original.seasonNumber),
+    enableRowSelection: true,
     mantineTableProps: {
       highlightOnHover: false,
       striped: "odd",

packages/settings/index.ts

@@ -1,2 +1 @@
 export * from "./src/context";
-export * from "./src/preferences/definitions";

packages/settings/src/preferences/definitions.ts

@@ -1,78 +0,0 @@
-export const userPreferenceDefinitions = [
-  {
-    key: "colorScheme",
-    kind: "select",
-    guest: true,
-    mutationGroup: "colorScheme",
-    aliases: ["theme", "dark", "light", "auto"],
-  },
-  { key: "locale", kind: "select", guest: true, mutationGroup: "locale", aliases: ["language", "translation"] },
-  {
-    key: "defaultSearchEngineId",
-    kind: "searchEngine",
-    guest: false,
-    mutationGroup: "searchPreferences",
-    aliases: ["search", "search engine"],
-  },
-  {
-    key: "openSearchInNewTab",
-    kind: "boolean",
-    guest: false,
-    mutationGroup: "searchPreferences",
-    aliases: ["search", "new tab", "external"],
-  },
-  {
-    key: "ddgBangs",
-    kind: "boolean",
-    guest: false,
-    mutationGroup: "searchPreferences",
-    aliases: ["duckduckgo", "bangs", "search"],
-  },
-  {
-    key: "firstDayOfWeek",
-    kind: "select",
-    guest: false,
-    mutationGroup: "firstDayOfWeek",
-    aliases: ["calendar", "week", "weekday"],
-  },
-  {
-    key: "homeBoardId",
-    kind: "board",
-    guest: false,
-    mutationGroup: "homeBoards",
-    aliases: ["home", "board", "dashboard"],
-  },
-  {
-    key: "mobileHomeBoardId",
-    kind: "board",
-    guest: false,
-    mutationGroup: "homeBoards",
-    aliases: ["mobile", "home", "board", "dashboard"],
-  },
-  {
-    key: "pingIconsEnabled",
-    kind: "boolean",
-    guest: false,
-    mutationGroup: "pingIconsEnabled",
-    aliases: ["ping", "icon", "status"],
-  },
-  {
-    key: "fullPreferencesPage",
-    kind: "link",
-    guest: false,
-    mutationGroup: null,
-    aliases: ["settings", "manage", "profile"],
-  },
-] as const;
-
-export type UserPreferenceDefinition = (typeof userPreferenceDefinitions)[number];
-export type UserPreferenceKey = UserPreferenceDefinition["key"];
-export type UserPreferenceKind = UserPreferenceDefinition["kind"];
-export type UserPreferenceMutationGroup = Exclude<UserPreferenceDefinition["mutationGroup"], null>;
-
-export const userPreferenceDefinitionByKey = Object.fromEntries(
-  userPreferenceDefinitions.map((definition) => [definition.key, definition]),
-) as Record<UserPreferenceKey, UserPreferenceDefinition>;
-
-export const visiblePreferenceDefinitions = (isAuthenticated: boolean) =>
-  userPreferenceDefinitions.filter((definition) => definition.guest || isAuthenticated);

packages/spotlight/package.json

@@ -29,7 +29,6 @@
     "@homarr/integrations": "workspace:^0.1.0",
     "@homarr/modals": "workspace:^0.1.0",
     "@homarr/modals-collection": "workspace:^0.1.0",
-    "@homarr/notifications": "workspace:^0.1.0",
     "@homarr/settings": "workspace:^0.1.0",
     "@homarr/translation": "workspace:^0.1.0",
     "@homarr/ui": "workspace:^0.1.0",

packages/spotlight/src/components/actions/items/children-action-item.tsx

@@ -33,10 +33,7 @@ export const ChildrenActionItem = ({ childrenOptions, action, query, setChildren
     <Spotlight.Action
       renderRoot={renderRoot}
       onClick={onClick}
-      closeSpotlightOnTrigger={
-        interaction.type !== "children" &&
-        (interaction.type !== "javaScript" || interaction.closeSpotlightOnTrigger !== false)
-      }
+      closeSpotlightOnTrigger={interaction.type !== "children"}
       className={classes.spotlightAction}
     >
       <action.Component {...childrenOptions.option} />

packages/spotlight/src/components/actions/items/group-action-item.tsx

@@ -44,9 +44,6 @@ export const SpotlightGroupActionItem = <TOption extends Record<string, unknown>
       setQuery(interaction.query);
       setTimeout(() => selectAction(0, spotlightStore));
     } else if (interaction.type === "mode") {
-      if (interaction.query !== undefined) {
-        setQuery(interaction.query);
-      }
       setMode(interaction.mode);
     } else if (interaction.type === "children") {
       setChildrenOptions(interaction);
@@ -61,8 +58,7 @@ export const SpotlightGroupActionItem = <TOption extends Record<string, unknown>
         interaction.type !== "mode" &&
         interaction.type !== "children" &&
         interaction.type !== "none" &&
-        interaction.type !== "setQuery" &&
-        (interaction.type !== "javaScript" || interaction.closeSpotlightOnTrigger !== false)
+        interaction.type !== "setQuery"
       }
       className={classes.spotlightAction}
     >

packages/spotlight/src/components/spotlight.tsx

@@ -1,33 +1,24 @@
 "use client";
 
 import type { Dispatch, SetStateAction } from "react";
-import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { useMemo, useRef, useState } from "react";
 import { ActionIcon, Center, Group, Kbd } from "@mantine/core";
 import { Spotlight as MantineSpotlight } from "@mantine/spotlight";
-import { IconArrowLeft, IconSearch, IconX } from "@tabler/icons-react";
-import { useSetAtom } from "jotai";
+import { IconSearch, IconX } from "@tabler/icons-react";
 
 import { hotkeys } from "@homarr/definitions";
 import type { TranslationObject } from "@homarr/translation";
 import { useI18n } from "@homarr/translation/client";
 
-import type { OpenMediaRequestSearchOptions } from "../index";
 import type { inferSearchInteractionOptions } from "../lib/interaction";
 import type { SearchMode } from "../lib/mode";
 import { searchModes } from "../modes";
-import { useHomeEmptyGroupsWithPreferences } from "../modes/help/home-empty-groups";
-import {
-  mediaRequestSearchEvent,
-  mediaRequestSearchScopeAtom,
-  selectAction,
-  spotlightActions,
-  spotlightStore,
-} from "../spotlight-store";
+import { useHomeEmptyGroups } from "../modes/help/home-empty-groups";
+import { selectAction, spotlightStore } from "../spotlight-store";
 import { SpotlightChildrenActions } from "./actions/children-actions";
 import { SpotlightActionGroups } from "./actions/groups/action-group";
 
 type SearchModeKey = keyof TranslationObject["search"]["mode"];
-type ChildrenOptions = inferSearchInteractionOptions<"children">;
 
 const defaultMode = "home";
 export const Spotlight = () => {
@@ -40,6 +31,7 @@ export const Spotlight = () => {
     return null;
   }
 
+  // We use the "key" below to prevent the 'Different amounts of hooks' error
   return (
     <SpotlightWithActiveMode key={mode} modeState={searchModeState} queryState={queryState} activeMode={activeMode} />
   );
@@ -54,57 +46,13 @@ interface SpotlightWithActiveModeProps {
 const SpotlightWithActiveMode = ({ modeState, queryState, activeMode }: SpotlightWithActiveModeProps) => {
   const [query, setQuery] = queryState;
   const [mode, setMode] = modeState;
-  const [childrenStack, setChildrenStack] = useState<ChildrenOptions[]>([]);
-  const childrenOptions = childrenStack.at(-1) ?? null;
+  const [childrenOptions, setChildrenOptions] = useState<inferSearchInteractionOptions<"children"> | null>(null);
   const t = useI18n();
   const inputRef = useRef<HTMLInputElement>(null);
-  const setMediaRequestSearchScope = useSetAtom(mediaRequestSearchScopeAtom);
+  // Works as always the same amount of hooks are executed
   const useGroups = "groups" in activeMode ? () => activeMode.groups : activeMode.useGroups;
   const groups = useGroups();
-  const homeEmptyGroups = useHomeEmptyGroupsWithPreferences();
-  const hasModeCharacter = activeMode.modeKey !== defaultMode && activeMode.character !== undefined;
-
-  const clearChildrenStack = useCallback(() => {
-    setChildrenStack([]);
-  }, []);
-
-  const pushChildrenOptions = useCallback(
-    (options: ChildrenOptions) => {
-      setChildrenStack((currentStack) => [...currentStack, options]);
-      setQuery("");
-      setTimeout(() => selectAction(0, spotlightStore));
-    },
-    [setQuery],
-  );
-
-  const popChildrenOptions = useCallback(() => {
-    setChildrenStack((currentStack) => currentStack.slice(0, -1));
-    setQuery("");
-    setTimeout(() => selectAction(0, spotlightStore));
-  }, [setQuery]);
-
-  useEffect(() => {
-    const handleMediaRequestSearch = (event: Event) => {
-      const { integrationIds, query } = (event as CustomEvent<OpenMediaRequestSearchOptions>).detail ?? {};
-      setMediaRequestSearchScope({ integrationIds });
-      setMode("media");
-      clearChildrenStack();
-      setQuery(query ?? "");
-      spotlightActions.open();
-      setTimeout(() => selectAction(0, spotlightStore));
-    };
-
-    window.addEventListener(mediaRequestSearchEvent, handleMediaRequestSearch);
-    return () => {
-      window.removeEventListener(mediaRequestSearchEvent, handleMediaRequestSearch);
-    };
-  }, [setMediaRequestSearchScope, setMode, setQuery, clearChildrenStack]);
-
-  useEffect(() => {
-    if (mode !== "media") {
-      setMediaRequestSearchScope({});
-    }
-  }, [mode, setMediaRequestSearchScope]);
+  const homeEmptyGroups = useHomeEmptyGroups();
 
   return (
     <MantineSpotlight.Root
@@ -113,7 +61,7 @@ const SpotlightWithActiveMode = ({ modeState, queryState, activeMode }: Spotligh
       overlayProps={{ blur: 2, backgroundOpacity: 0.2 }}
       onSpotlightClose={() => {
         setMode(defaultMode);
-        clearChildrenStack();
+        setChildrenOptions(null);
         setQuery("");
       }}
       query={query}
@@ -121,14 +69,17 @@ const SpotlightWithActiveMode = ({ modeState, queryState, activeMode }: Spotligh
         const sanitizedQuery = mode === "external" && nextQuery.startsWith("!") ? nextQuery.slice(1) : nextQuery;
         setQuery(sanitizedQuery);
 
+        // Only switch modes when a single trigger character is typed
         if (sanitizedQuery.length !== 1) return;
 
-        const modeToActivate = searchModes.find((searchMode) => searchMode.character === sanitizedQuery);
+        const modeToActivate = searchModes.find((mode) => mode.character === sanitizedQuery);
         if (!modeToActivate) return;
 
         setMode(modeToActivate.modeKey);
-        clearChildrenStack();
+        setChildrenOptions(null);
+
         setQuery("");
+
         setTimeout(() => selectAction(0, spotlightStore));
       }}
       store={spotlightStore}
@@ -136,13 +87,13 @@ const SpotlightWithActiveMode = ({ modeState, queryState, activeMode }: Spotligh
       <MantineSpotlight.Search
         placeholder={`${t("search.placeholder")}...`}
         ref={inputRef}
-        leftSectionWidth={hasModeCharacter ? 80 : 48}
+        leftSectionWidth={activeMode.modeKey !== defaultMode ? 80 : 48}
         leftSection={
           <Group align="center" wrap="nowrap" gap="xs" w="100%" h="100%">
             <Center w={48} h="100%">
               <IconSearch stroke={1.5} />
             </Center>
-            {hasModeCharacter ? <Kbd size="sm">{activeMode.character}</Kbd> : null}
+            {activeMode.modeKey !== defaultMode ? <Kbd size="sm">{activeMode.character}</Kbd> : null}
           </Group>
         }
         styles={{
@@ -151,53 +102,31 @@ const SpotlightWithActiveMode = ({ modeState, queryState, activeMode }: Spotligh
           },
         }}
         rightSection={
-          mode === defaultMode && childrenStack.length === 0 ? null : (
+          mode === defaultMode ? null : (
             <ActionIcon
-              title={
-                childrenStack.length > 0
-                  ? t("search.mode.command.group.preferences.children.detail.backAction")
-                  : t("common.action.close")
-              }
               onClick={() => {
-                if (childrenStack.length > 0) {
-                  popChildrenOptions();
-                  inputRef.current?.focus();
-                  return;
-                }
-
                 setMode(defaultMode);
-                clearChildrenStack();
+                setChildrenOptions(null);
                 inputRef.current?.focus();
               }}
               variant="subtle"
-              aria-label={
-                childrenStack.length > 0
-                  ? t("search.mode.command.group.preferences.children.detail.backAction")
-                  : t("common.action.close")
-              }
+              aria-label={t("common.action.close")}
             >
-              {childrenStack.length > 0 ? <IconArrowLeft stroke={1.5} /> : <IconX stroke={1.5} />}
+              <IconX stroke={1.5} />
             </ActionIcon>
           )
         }
         value={query}
         onKeyDown={(event) => {
-          if (query.length !== 0 || event.key !== "Backspace") return;
-
-          if (childrenStack.length > 0) {
-            popChildrenOptions();
-            return;
-          }
-
-          if (mode !== defaultMode) {
+          if (query.length === 0 && mode !== defaultMode && event.key === "Backspace") {
             setMode(defaultMode);
-            clearChildrenStack();
+            setChildrenOptions(null);
           }
         }}
       />
 
       {childrenOptions ? (
-        <Group key={childrenStack.length}>
+        <Group>
           <childrenOptions.DetailComponent options={childrenOptions.option as never} />
         </Group>
       ) : null}
@@ -205,21 +134,25 @@ const SpotlightWithActiveMode = ({ modeState, queryState, activeMode }: Spotligh
       <MantineSpotlight.ActionsList>
         {childrenOptions ? (
           <SpotlightChildrenActions
-            key={childrenStack.length}
             childrenOptions={childrenOptions}
             query={query}
-            setChildrenOptions={pushChildrenOptions}
+            setChildrenOptions={setChildrenOptions}
           />
         ) : (
           <SpotlightActionGroups
             setQuery={setQuery}
-            setMode={(nextMode) => {
-              setMode(nextMode);
-              clearChildrenStack();
+            setMode={(mode) => {
+              setMode(mode);
+              setChildrenOptions(null);
               setTimeout(() => selectAction(0, spotlightStore));
             }}
             setChildrenOptions={(options) => {
-              pushChildrenOptions(options);
+              setChildrenOptions(options);
+
+              setTimeout(() => {
+                setQuery("");
+                selectAction(0, spotlightStore);
+              });
             }}
             query={query}
             groups={mode === defaultMode && query.length === 0 ? [...homeEmptyGroups] : groups}

packages/spotlight/src/index.ts

@@ -1,9 +1,9 @@
 "use client";
 
-import { mediaRequestSearchEvent, spotlightActions } from "./spotlight-store";
+import { spotlightActions } from "./spotlight-store";
 
 export { Spotlight } from "./components/spotlight";
-export { openSpotlight, openMediaRequestSearch };
+export { openSpotlight };
 export {
   SpotlightProvider,
   useRegisterSpotlightContextResults,
@@ -11,18 +11,3 @@ export {
 } from "./modes/home/context";
 
 const openSpotlight = spotlightActions.open;
-
-export interface OpenMediaRequestSearchOptions {
-  integrationIds?: string[];
-  query?: string;
-}
-
-const openMediaRequestSearch = (options: OpenMediaRequestSearchOptions = {}) => {
-  if (typeof window !== "undefined") {
-    window.dispatchEvent(new CustomEvent<OpenMediaRequestSearchOptions>(mediaRequestSearchEvent, { detail: options }));
-  }
-
-  spotlightActions.open();
-};
-
-export { mediaRequestSearchEvent };

packages/spotlight/src/lib/interaction.ts

@@ -10,12 +10,9 @@ const createSearchInteraction = <TType extends string>(type: TType) => ({
 // This is used to define search interactions with their options
 const searchInteractions = [
   createSearchInteraction("link").optionsType<{ href: string; newTab?: boolean }>(),
-  createSearchInteraction("javaScript").optionsType<{
-    onSelect: () => MaybePromise<void>;
-    closeSpotlightOnTrigger?: boolean;
-  }>(),
+  createSearchInteraction("javaScript").optionsType<{ onSelect: () => MaybePromise<void> }>(),
   createSearchInteraction("setQuery").optionsType<{ query: string }>(),
-  createSearchInteraction("mode").optionsType<{ mode: keyof TranslationObject["search"]["mode"]; query?: string }>(),
+  createSearchInteraction("mode").optionsType<{ mode: keyof TranslationObject["search"]["mode"] }>(),
   createSearchInteraction("children").optionsType<{
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     useActions: CreateChildrenOptionsProps<any>["useActions"];

packages/spotlight/src/modes/command/children/language.tsx

@@ -1,17 +1,16 @@
-import { Group, Text } from "@mantine/core";
+import { Group, Stack, Text } from "@mantine/core";
+import { IconCheck } from "@tabler/icons-react";
 
 import { localeConfigurations, supportedLanguages } from "@homarr/translation";
-import { useUserPreference } from "../../../preferences/use-user-preference";
+import { useChangeLocale, useCurrentLocale, useI18n } from "@homarr/translation/client";
 import { LanguageIcon } from "@homarr/ui";
 
 import { createChildrenOptions } from "../../../lib/children";
-import { createCheckmarkPreferenceAction, PreferenceDetailHeader } from "./preferences/action-row";
 
 export const languageChildrenOptions = createChildrenOptions<Record<string, unknown>>({
   useActions: (_, query) => {
     const normalizedQuery = query.trim().toLowerCase();
-    const { value: currentLocale, setValue: setLocale, isPending } = useUserPreference("locale");
-
+    const currentLocale = useCurrentLocale();
     return supportedLanguages
       .map((localeKey) => ({ localeKey, configuration: localeConfigurations[localeKey] }))
       .filter(
@@ -19,7 +18,7 @@ export const languageChildrenOptions = createChildrenOptions<Record<string, unkn
           configuration.name.toLowerCase().includes(normalizedQuery) ||
           configuration.translatedName.toLowerCase().includes(normalizedQuery),
       )
-      .toSorted(
+      .sort(
         (languageA, languageB) =>
           Math.min(
             languageA.configuration.name.toLowerCase().indexOf(normalizedQuery),
@@ -30,25 +29,38 @@ export const languageChildrenOptions = createChildrenOptions<Record<string, unkn
             languageB.configuration.translatedName.toLowerCase().indexOf(normalizedQuery),
           ),
       )
-      .map(({ localeKey, configuration }) =>
-        createCheckmarkPreferenceAction({
-          key: localeKey,
-          isSelected: localeKey === currentLocale,
-          onSelect: () => setLocale(localeKey as never),
-          isPending,
-          labelContent: (
-            <Group wrap="nowrap">
-              <LanguageIcon icon={localeConfigurations[localeKey].icon} />
-              <Group wrap="nowrap" gap="xs">
-                <Text>{configuration.name}</Text>
-                <Text size="xs" c="dimmed" inherit>
-                  ({configuration.translatedName})
-                </Text>
+      .map(({ localeKey, configuration }) => ({
+        key: localeKey,
+        Component() {
+          return (
+            <Group mx="md" my="sm" wrap="nowrap" justify="space-between" w="100%">
+              <Group wrap="nowrap">
+                <LanguageIcon icon={localeConfigurations[localeKey].icon} />
+                <Group wrap="nowrap" gap="xs">
+                  <Text>{configuration.name}</Text>
+                  <Text size="xs" c="dimmed" inherit>
+                    ({configuration.translatedName})
+                  </Text>
+                </Group>
               </Group>
+              {localeKey === currentLocale && <IconCheck color="currentColor" size={24} />}
             </Group>
-          ),
-        }),
-      );
+          );
+        },
+        useInteraction() {
+          const { changeLocale } = useChangeLocale();
+
+          return { type: "javaScript", onSelect: () => changeLocale(localeKey) };
+        },
+      }));
+  },
+  DetailComponent: () => {
+    const t = useI18n();
+
+    return (
+      <Stack mx="md" my="sm">
+        <Text>{t("search.mode.command.group.globalCommand.option.language.children.detail.title")}</Text>
+      </Stack>
+    );
   },
-  DetailComponent: () => <PreferenceDetailHeader titleKey="locale.children.detail.title" />,
 });

packages/spotlight/src/modes/command/children/preferences/action-row.tsx

@@ -1,68 +0,0 @@
-import type { ReactNode } from "react";
-import { Center, Group, Loader, Stack, Text } from "@mantine/core";
-import { IconCheck } from "@tabler/icons-react";
-
-import { useScopedI18n } from "@homarr/translation/client";
-
-import { interaction } from "../../../../lib/interaction";
-
-export const PreferenceDetailHeader = ({ titleKey }: { titleKey: string }) => {
-  const tOption = useScopedI18n("search.mode.command.group.preferences.option");
-  const t = useScopedI18n("search.mode.command.group.preferences");
-
-  return (
-    <Stack mx="md" my="sm" gap="xs">
-      <Text>{tOption(titleKey as never)}</Text>
-      <Text size="xs" c="dimmed">
-        {t("children.detail.backHint")}
-      </Text>
-    </Stack>
-  );
-};
-
-export const createCheckmarkPreferenceAction = ({
-  key,
-  label,
-  labelContent,
-  isSelected,
-  onSelect,
-  dimmed,
-  isPending,
-}: {
-  key: string;
-  label?: string;
-  labelContent?: ReactNode;
-  isSelected: boolean;
-  onSelect: () => void;
-  dimmed?: boolean;
-  isPending?: boolean;
-}) => ({
-  key,
-  Component() {
-    return (
-      <Group mx="md" my="sm" wrap="nowrap" justify="space-between" w="100%" opacity={isPending ? 0.5 : 1}>
-        {labelContent ?? <Text c={dimmed ? "dimmed" : undefined}>{label}</Text>}
-        {isSelected && <IconCheck color="currentColor" size={24} />}
-      </Group>
-    );
-  },
-  useInteraction: interaction.javaScript(() => ({
-    onSelect: isPending ? () => undefined : onSelect,
-    closeSpotlightOnTrigger: false,
-  })),
-});
-
-export const createLoadingPreferenceAction = () => ({
-  key: "loading",
-  Component() {
-    return (
-      <Center mx="md" my="sm">
-        <Loader size="sm" />
-      </Center>
-    );
-  },
-  useInteraction: interaction.javaScript(() => ({
-    onSelect: () => undefined,
-    closeSpotlightOnTrigger: false,
-  })),
-});

packages/spotlight/src/modes/command/children/preferences/index.tsx

@@ -1 +0,0 @@
-export { settingsChildrenOptions } from "./settings-children";

packages/spotlight/src/modes/command/children/preferences/selectable-actions.tsx

@@ -1,55 +0,0 @@
-import { createCheckmarkPreferenceAction } from "./action-row";
-
-interface SelectablePreferenceItem {
-  key: string;
-  label: string;
-  value: string;
-}
-
-export const createSelectablePreferenceActions = ({
-  query,
-  currentValue,
-  noneLabel,
-  unavailableLabel,
-  items,
-  onSelect,
-  isPending,
-}: {
-  query: string;
-  currentValue: string | null;
-  noneLabel: string;
-  unavailableLabel: string;
-  items: SelectablePreferenceItem[];
-  onSelect: (value: string | null) => void;
-  isPending?: boolean;
-}) => {
-  const hasCurrentSelection = currentValue !== null && !items.some((item) => item.value === currentValue);
-  const orphanedItem: SelectablePreferenceItem | null = hasCurrentSelection
-    ? { key: `orphaned-${currentValue}`, label: unavailableLabel, value: currentValue }
-    : null;
-  const normalizedQuery = query.trim().toLowerCase();
-  const filteredItems = items.filter((item) => item.label.toLowerCase().includes(normalizedQuery));
-  const visibleItems = orphanedItem ? [orphanedItem, ...filteredItems] : filteredItems;
-
-  const noneAction = createCheckmarkPreferenceAction({
-    key: "none",
-    label: noneLabel,
-    isSelected: currentValue === null,
-    onSelect: () => onSelect(null),
-    dimmed: true,
-    isPending,
-  });
-
-  const itemActions = visibleItems.map((item) =>
-    createCheckmarkPreferenceAction({
-      key: item.key,
-      label: item.label,
-      isSelected: currentValue === item.value,
-      onSelect: () => onSelect(item.value),
-      dimmed: item.key.startsWith("orphaned-"),
-      isPending,
-    }),
-  );
-
-  return [noneAction, ...itemActions];
-};

packages/spotlight/src/modes/command/children/preferences/settings-children.tsx

@@ -1,156 +0,0 @@
-"use client";
-
-import { Group, Stack, Switch, Text } from "@mantine/core";
-import type { DayOfWeek } from "@mantine/dates";
-import dayjs from "dayjs";
-import localeData from "dayjs/plugin/localeData";
-
-import { clientApi } from "@homarr/api/client";
-import { useSession } from "@homarr/auth/client";
-import type { ColorScheme } from "@homarr/definitions";
-import { visiblePreferenceDefinitions } from "@homarr/settings";
-import { localeConfigurations } from "@homarr/translation";
-import { useScopedI18n } from "@homarr/translation/client";
-import type { TablerIcon } from "@homarr/ui";
-
-import { createChildrenOptions } from "../../../../lib/children";
-import type { ChildrenAction } from "../../../../lib/children";
-import { interaction } from "../../../../lib/interaction";
-import { useUserPreferences } from "../../../../preferences/use-user-preference";
-import { preferenceChildrenOptionsByKey, preferenceIcons } from "../../../../preferences/preference-registry";
-
-dayjs.extend(localeData);
-
-type SettingsAction = ChildrenAction<Record<string, unknown>>;
-
-const BooleanRow = ({
-  label,
-  Icon,
-  checked,
-  isPending,
-}: {
-  label: string;
-  Icon: TablerIcon;
-  checked: boolean;
-  isPending: boolean;
-}) => (
-  <Group mx="md" my="sm" wrap="nowrap" justify="space-between" w="100%">
-    <Group wrap="nowrap" gap="sm">
-      <Icon stroke={1.5} size={20} />
-      <Text>{label}</Text>
-    </Group>
-    <Switch checked={checked} readOnly size="md" disabled={isPending} styles={{ track: { cursor: "pointer" } }} />
-  </Group>
-);
-
-const SelectRow = ({ label, Icon, valueLabel }: { label: string; Icon: TablerIcon; valueLabel: string }) => (
-  <Group mx="md" my="sm" wrap="nowrap" justify="space-between" w="100%">
-    <Group wrap="nowrap" gap="sm">
-      <Icon stroke={1.5} size={20} />
-      <Text>{label}</Text>
-    </Group>
-    <Text size="sm" c="dimmed">
-      {valueLabel}
-    </Text>
-  </Group>
-);
-
-const LinkRow = ({ label, Icon }: { label: string; Icon: TablerIcon }) => (
-  <Group mx="md" my="sm" wrap="nowrap" gap="sm">
-    <Icon stroke={1.5} size={20} />
-    <Text>{label}</Text>
-  </Group>
-);
-
-const SELECT_KINDS = new Set(["select", "searchEngine", "board"]);
-
-const useSettingsActions = (_: Record<string, unknown>, query: string): SettingsAction[] => {
-  const t = useScopedI18n("search.mode.command.group.preferences.option");
-  const tColorScheme = useScopedI18n("common.colorScheme.options");
-  const { data: session } = useSession();
-  const isAuthenticated = Boolean(session?.user);
-  const normalizedQuery = query.trim().toLowerCase();
-  const preferences = useUserPreferences();
-
-  const boardsQuery = clientApi.board.getAllBoards.useQuery(undefined, { enabled: isAuthenticated });
-  const searchEnginesQuery = clientApi.searchEngine.getSelectable.useQuery(undefined, { enabled: isAuthenticated });
-
-  const valueLabelResolvers: Record<string, () => string> = {
-    colorScheme: () => tColorScheme(preferences.getPreference("colorScheme").value as ColorScheme),
-    locale: () => {
-      const val = preferences.getPreference("locale").value;
-      return localeConfigurations[val as keyof typeof localeConfigurations]?.name ?? String(val);
-    },
-    defaultSearchEngineId: () =>
-      searchEnginesQuery.data?.find((e) => e.value === preferences.getPreference("defaultSearchEngineId").value)
-        ?.label ?? t("searchEngine.none" as never),
-    firstDayOfWeek: () => dayjs.weekdays(false)[preferences.getPreference("firstDayOfWeek").value as DayOfWeek] ?? "",
-    homeBoardId: () =>
-      boardsQuery.data?.find((b) => b.id === preferences.getPreference("homeBoardId").value)?.name ??
-      t("board.none" as never),
-    mobileHomeBoardId: () =>
-      boardsQuery.data?.find((b) => b.id === preferences.getPreference("mobileHomeBoardId").value)?.name ??
-      t("board.none" as never),
-  };
-
-  return visiblePreferenceDefinitions(isAuthenticated)
-    .map((definition): SettingsAction | null => {
-      const label = t(`${definition.key}.label` as never);
-      const Icon = preferenceIcons[definition.key];
-
-      const matchesSearch = [label, ...definition.aliases].some((v) => v.toLowerCase().includes(normalizedQuery));
-      if (!matchesSearch) return null;
-
-      if (definition.kind === "boolean") {
-        const pref = preferences.getPreference(definition.key);
-        return {
-          key: definition.key,
-          Component: () => (
-            <BooleanRow label={label} Icon={Icon} checked={pref.value as boolean} isPending={pref.isPending} />
-          ),
-          useInteraction: interaction.javaScript(() => ({
-            onSelect: pref.isPending ? () => undefined : () => pref.setValue(!(pref.value as boolean) as never),
-            closeSpotlightOnTrigger: false,
-          })),
-        };
-      }
-
-      if (definition.kind === "link") {
-        return {
-          key: definition.key,
-          Component: () => <LinkRow label={label} Icon={Icon} />,
-          useInteraction: interaction.link(() => ({ href: `/manage/users/${session?.user.id ?? ""}/general` })),
-        };
-      }
-
-      if (SELECT_KINDS.has(definition.kind)) {
-        const children = preferenceChildrenOptionsByKey[definition.key];
-        if (!children) return null;
-        return {
-          key: definition.key,
-          Component: () => (
-            <SelectRow label={label} Icon={Icon} valueLabel={valueLabelResolvers[definition.key]?.() ?? ""} />
-          ),
-          useInteraction: interaction.children(children),
-        };
-      }
-
-      return null;
-    })
-    .filter((action): action is SettingsAction => action !== null);
-};
-
-export const settingsChildrenOptions = createChildrenOptions<Record<string, unknown>>({
-  useActions: useSettingsActions,
-  DetailComponent: () => {
-    const t = useScopedI18n("search.mode.command.group.preferences");
-    return (
-      <Stack mx="md" my="sm" gap="xs">
-        <Text>{t("title")}</Text>
-        <Text size="xs" c="dimmed">
-          {t("children.detail.backHint")}
-        </Text>
-      </Stack>
-    );
-  },
-});

packages/spotlight/src/modes/command/global-group.tsx

@@ -1,10 +1,14 @@
-import { Group, Text } from "@mantine/core";
+import { Group, Text, useComputedColorScheme, useMantineColorScheme } from "@mantine/core";
 import {
   IconBox,
   IconCategoryPlus,
+  IconDeviceDesktop,
   IconFileImport,
+  IconLanguage,
   IconMailForward,
+  IconMoon,
   IconPlug,
+  IconSun,
   IconUserPlus,
   IconUsersGroup,
 } from "@tabler/icons-react";
@@ -18,6 +22,7 @@ import type { TablerIcon } from "@homarr/ui";
 import { createGroup } from "../../lib/group";
 import type { inferSearchInteractionDefinition, SearchInteraction } from "../../lib/interaction";
 import { interaction } from "../../lib/interaction";
+import { languageChildrenOptions } from "./children/language";
 import { newIntegrationChildrenOptions } from "./children/new-integration";
 
 // This has to be type so it can be interpreted as Record<string, unknown>.
@@ -47,9 +52,33 @@ export const globalCommandGroup = createGroup<Command>({
   },
   useOptions() {
     const tOption = useScopedI18n("search.mode.command.group.globalCommand.option");
+    const { colorScheme } = useMantineColorScheme();
+    const computedColorScheme = useComputedColorScheme("light");
     const { data: session } = useSession();
 
     const commands: (Command & { hidden?: boolean })[] = [
+      {
+        commandKey: "colorScheme",
+        icon: colorScheme === "auto" ? IconDeviceDesktop : computedColorScheme === "dark" ? IconSun : IconMoon,
+        name:
+          colorScheme === "auto"
+            ? tOption("colorScheme.auto")
+            : tOption(`colorScheme.${computedColorScheme === "dark" ? "light" : "dark"}`),
+        useInteraction: () => {
+          const { toggleColorScheme } = useMantineColorScheme();
+
+          return {
+            type: "javaScript",
+            onSelect: toggleColorScheme,
+          };
+        },
+      },
+      {
+        commandKey: "language",
+        icon: IconLanguage,
+        name: tOption("language.label"),
+        useInteraction: interaction.children(languageChildrenOptions),
+      },
       {
         commandKey: "newBoard",
         icon: IconCategoryPlus,

packages/spotlight/src/modes/command/index.tsx

@@ -1,10 +1,9 @@
 import type { SearchMode } from "../../lib/mode";
 import { contextSpecificActionsSearchGroups } from "./context-specific-group";
 import { globalCommandGroup } from "./global-group";
-import { preferencesGroup } from "../preferences/groups";
 
 export const commandMode = {
   modeKey: "command",
   character: ">",
-  groups: [contextSpecificActionsSearchGroups, preferencesGroup, globalCommandGroup],
+  groups: [contextSpecificActionsSearchGroups, globalCommandGroup],
 } satisfies SearchMode;

packages/spotlight/src/modes/external/search-engines-search-group.tsx

@@ -64,36 +64,6 @@ type MediaRequestChildrenProps = {
     kind: IntegrationKind;
     url: string;
     id: string;
-    permissions?: {
-      hasInteractAccess: boolean;
-    };
-  };
-};
-
-export const useMediaRequestSearchInteraction = (
-  integration: MediaRequestChildrenProps["integration"],
-  searchResult: FromIntegrationSearchResult,
-): inferSearchInteractionDefinition<"link" | "children"> => {
-  const { openSearchInNewTab } = useSettings();
-
-  const type = searchResult.type;
-  if (type === "person") {
-    return {
-      type: "link",
-      href: searchResult.link,
-      newTab: openSearchInNewTab,
-    };
-  }
-
-  return {
-    type: "children",
-    ...mediaRequestsChildrenOptions({
-      result: {
-        ...searchResult,
-        type,
-      },
-      integration,
-    }),
   };
 };
 
@@ -101,6 +71,8 @@ export const useFromIntegrationSearchInteraction = (
   searchEngine: SearchEngine,
   searchResult: FromIntegrationSearchResult,
 ): inferSearchInteractionDefinition<"link" | "javaScript" | "children"> => {
+  const { openSearchInNewTab } = useSettings();
+
   if (searchEngine.type !== "fromIntegration") {
     throw new Error("Invalid search engine type");
   }
@@ -115,7 +87,25 @@ export const useFromIntegrationSearchInteraction = (
     ) &&
     "type" in searchResult
   ) {
-    return useMediaRequestSearchInteraction(searchEngine.integration, searchResult);
+    const type = searchResult.type;
+    if (type === "person") {
+      return {
+        type: "link",
+        href: searchResult.link,
+        newTab: openSearchInNewTab,
+      };
+    }
+
+    return {
+      type: "children",
+      ...mediaRequestsChildrenOptions({
+        result: {
+          ...searchResult,
+          type,
+        },
+        integration: searchEngine.integration,
+      }),
+    };
   }
 
   return {
@@ -125,15 +115,13 @@ export const useFromIntegrationSearchInteraction = (
   };
 };
 
-export const mediaRequestsChildrenOptions = createChildrenOptions<MediaRequestChildrenProps>({
+const mediaRequestsChildrenOptions = createChildrenOptions<MediaRequestChildrenProps>({
   useActions() {
     const { openModal } = useModalAction(RequestMediaModal);
     return [
       {
         key: "request",
-        hide: (option) =>
-          (option.result.type === "movie" && option.result.inLibrary) ||
-          option.integration.permissions?.hasInteractAccess === false,
+        hide: (option) => option.result.inLibrary,
         Component(option) {
           const t = useScopedI18n("search.mode.media");
           return (

packages/spotlight/src/modes/help/home-empty-groups.tsx

@@ -19,13 +19,12 @@ import type { SearchMode } from "../../lib/mode";
 import { appIntegrationBoardMode } from "../app-integration-board";
 import { commandMode } from "../command";
 import { externalMode } from "../external";
-import { mediaMode } from "../media";
 import { pageMode } from "../page";
-import { preferencesGroup } from "../preferences/groups";
 import { userGroupMode } from "../user-group";
 
+// We need type to allow it as generic type for Record<string, unknown>
+// eslint-disable-next-line @typescript-eslint/consistent-type-definitions
 type QuickLinkOption = {
-  key: string;
   icon: TablerIcon;
   name: string;
   path: string;
@@ -34,7 +33,7 @@ type QuickLinkOption = {
 export const useHomeEmptyGroups = () => {
   const { data: session } = useSession();
   const tPages = useScopedI18n("search.mode.page.group.page.option");
-  const visibleSearchModes: SearchMode[] = [appIntegrationBoardMode, externalMode, mediaMode, commandMode, pageMode];
+  const visibleSearchModes: SearchMode[] = [appIntegrationBoardMode, externalMode, commandMode, pageMode];
 
   if (session?.user.permissions.includes("admin")) {
     visibleSearchModes.unshift(userGroupMode);
@@ -42,13 +41,19 @@ export const useHomeEmptyGroups = () => {
 
   return [
     createGroup({
-      keyPath: "key",
+      keyPath: "path",
       title: () => "Quick links",
       options: (() => {
         const quickLinks: QuickLinkOption[] = [];
+        if (session?.user) {
+          quickLinks.push({
+            icon: IconSettings,
+            path: `/manage/users/${session.user.id}/general`,
+            name: tPages("preferences.label"),
+          });
+        }
 
         quickLinks.push({
-          key: "manageBoards",
           icon: IconLayoutDashboard,
           path: "/manage/boards",
           name: tPages("manageBoard.label"),
@@ -56,7 +61,6 @@ export const useHomeEmptyGroups = () => {
 
         if (session?.user.permissions.includes("admin")) {
           quickLinks.push({
-            key: "manageSettings",
             icon: IconSettings,
             path: "/manage/settings",
             name: tPages("manageSettings.label"),
@@ -65,7 +69,6 @@ export const useHomeEmptyGroups = () => {
 
         if (session) {
           quickLinks.push({
-            key: "manageSearchEngines",
             icon: IconSearch,
             path: "/manage/search-engines",
             name: tPages("manageSearchEngine.label"),
@@ -84,7 +87,7 @@ export const useHomeEmptyGroups = () => {
       useInteraction: interaction.link(({ path }) => ({ href: path })),
     }),
     createGroup({
-      keyPath: "modeKey",
+      keyPath: "character",
       title: (t) => t("search.mode.help.group.mode.title"),
       options: visibleSearchModes.map(({ character, modeKey }) => ({ character, modeKey })),
       Component: ({ modeKey, character }) => {
@@ -93,7 +96,7 @@ export const useHomeEmptyGroups = () => {
         return (
           <Group px="md" py="xs" w="100%" wrap="nowrap" align="center" justify="space-between">
             <Text>{t("help")}</Text>
-            {character && <Kbd size="sm">{character}</Kbd>}
+            <Kbd size="sm">{character}</Kbd>
           </Group>
         );
       },
@@ -135,5 +138,3 @@ export const useHomeEmptyGroups = () => {
     }),
   ] as const;
 };
-
-export const useHomeEmptyGroupsWithPreferences = () => [preferencesGroup, ...useHomeEmptyGroups()];

packages/spotlight/src/modes/home/home-search-engine-group.tsx

@@ -20,7 +20,6 @@ type GroupItem = {
   name: string;
   description?: string;
   icon: TablerIcon | string;
-  disabled?: boolean;
   useInteraction: (query: string) => inferSearchInteractionDefinition<SearchInteraction>;
 };
 
@@ -38,7 +37,7 @@ export const homeSearchEngineGroup = createGroup<GroupItem>({
       );
 
     return (
-      <Group w="100%" wrap="nowrap" align="center" px="md" py="xs" opacity={item.disabled ? 0.55 : 1}>
+      <Group w="100%" wrap="nowrap" align="center" px="md" py="xs">
         {icon}
         <Stack gap={0}>
           <Text>{item.name}</Text>
@@ -92,7 +91,9 @@ const createDefaultSearchEntries = (
   query: string,
   t: TranslationFunction,
 ): GroupItem[] => {
-  if (!session?.user && !defaultSearchEngine) return [];
+  if (!session?.user && !defaultSearchEngine) {
+    return [];
+  }
 
   if (!defaultSearchEngine) {
     return [

packages/spotlight/src/modes/home/index.tsx

@@ -1,10 +1,9 @@
 import type { SearchMode } from "../../lib/mode";
-import { preferencesGroup } from "../preferences/groups";
 import { contextSpecificSearchGroups } from "./context-specific-group";
 import { homeSearchEngineGroup } from "./home-search-engine-group";
 
 export const homeMode = {
   character: undefined,
   modeKey: "home",
-  groups: [preferencesGroup, homeSearchEngineGroup, contextSpecificSearchGroups],
+  groups: [homeSearchEngineGroup, contextSpecificSearchGroups],
 } satisfies SearchMode;

packages/spotlight/src/modes/index.tsx

@@ -2,7 +2,6 @@ import { appIntegrationBoardMode } from "./app-integration-board";
 import { commandMode } from "./command";
 import { externalMode } from "./external";
 import { homeMode } from "./home";
-import { mediaMode } from "./media";
 import { pageMode } from "./page";
 import { userGroupMode } from "./user-group";
 
@@ -12,6 +11,5 @@ export const searchModes = [
   externalMode,
   commandMode,
   pageMode,
-  mediaMode,
   homeMode,
 ] as const;

packages/spotlight/src/modes/media/index.tsx

@@ -1,8 +0,0 @@
-import type { SearchMode } from "../../lib/mode";
-import { mediaRequestSearchGroup } from "./media-request-search-group";
-
-export const mediaMode = {
-  modeKey: "media",
-  character: undefined,
-  groups: [mediaRequestSearchGroup],
-} satisfies SearchMode;

packages/spotlight/src/modes/media/media-request-search-group.tsx

@@ -1,173 +0,0 @@
-import { Badge, Group, Image, Stack, Text } from "@mantine/core";
-import { useDebouncedValue } from "@mantine/hooks";
-import { IconMovie, IconSearch } from "@tabler/icons-react";
-import { keepPreviousData } from "@tanstack/react-query";
-import { useAtomValue } from "jotai";
-
-import type { RouterOutputs } from "@homarr/api";
-import { clientApi } from "@homarr/api/client";
-import { getIntegrationName } from "@homarr/definitions";
-import type { MediaAvailability } from "@homarr/integrations/types";
-import { mediaAvailabilityConfiguration } from "@homarr/integrations/types";
-import { useScopedI18n } from "@homarr/translation/client";
-
-import { createGroup } from "../../lib/group";
-import { mediaRequestSearchScopeAtom } from "../../spotlight-store";
-import { useMediaRequestSearchInteraction } from "../external/search-engines-search-group";
-
-const availabilityLabelKeys = ["available", "partiallyAvailable", "processing", "requested", "pending"] as const;
-type AvailabilityWithLabel = (typeof availabilityLabelKeys)[number];
-
-type MediaRequestSearchResult = RouterOutputs["integration"]["searchMediaRequests"][number];
-
-type MediaRequestSearchOption =
-  | {
-      key: string;
-      kind: "disabled" | "hint";
-      label: string;
-      description: string;
-    }
-  | {
-      key: string;
-      kind: "result";
-      result: MediaRequestSearchResult;
-    };
-
-export const mediaRequestSearchGroup = createGroup<MediaRequestSearchOption>({
-  keyPath: "key",
-  title: (t) => t("search.mode.media.group.title"),
-  Component(option) {
-    const tMedia = useScopedI18n("search.mode.media");
-
-    if (option.kind !== "result") {
-      return (
-        <Group w="100%" wrap="nowrap" align="center" px="md" py="xs" opacity={option.kind === "disabled" ? 0.55 : 1}>
-          {option.kind === "disabled" ? <IconMovie stroke={1.5} /> : <IconSearch stroke={1.5} />}
-          <Stack gap={0}>
-            <Text size="sm">{option.label}</Text>
-            <Text size="xs" c="gray.6">
-              {option.description}
-            </Text>
-          </Stack>
-        </Group>
-      );
-    }
-
-    const { result } = option;
-    const hasAvailabilityLabel =
-      result.availability && (availabilityLabelKeys as readonly string[]).includes(result.availability);
-    const badgeLabel = hasAvailabilityLabel
-      ? tMedia(`availability.${result.availability as AvailabilityWithLabel}`)
-      : undefined;
-    const badgeColor = result.availability
-      ? mediaAvailabilityConfiguration[result.availability as MediaAvailability]?.color
-      : undefined;
-
-    return (
-      <Group w="100%" wrap="nowrap" align="center" px="md" py="xs">
-        {result.image ? (
-          <Image src={result.image} w={35} h={50} fit="cover" radius="md" />
-        ) : (
-          <IconSearch stroke={1.5} size={35} />
-        )}
-        <Stack gap={2} style={{ flex: 1 }}>
-          <Group gap="xs" wrap="nowrap">
-            <Text>{result.name}</Text>
-            {badgeLabel && (
-              <Badge size="xs" color={badgeColor} variant="light">
-                {badgeLabel}
-              </Badge>
-            )}
-          </Group>
-          <Text c="dimmed" size="sm" lineClamp={2}>
-            {result.text ?? getIntegrationName(result.integration.kind)}
-          </Text>
-        </Stack>
-      </Group>
-    );
-  },
-  useInteraction(option) {
-    if (option.kind !== "result") {
-      return {
-        type: "none",
-      };
-    }
-
-    return useMediaRequestSearchInteraction(option.result.integration, option.result);
-  },
-  useQueryOptions(query) {
-    const tMedia = useScopedI18n("search.mode.media");
-    const scope = useAtomValue(mediaRequestSearchScopeAtom);
-    const [debouncedQuery] = useDebouncedValue(query.trim(), 150);
-    const targetsQuery = clientApi.integration.mediaRequestSearchTargets.useQuery();
-
-    const scopedTargets = (targetsQuery.data ?? []).filter((target) =>
-      scope.integrationIds ? scope.integrationIds.includes(target.id) : true,
-    );
-    const hasScopedTargets = scopedTargets.length > 0;
-    const shouldSearch = debouncedQuery.length > 0 && hasScopedTargets;
-    const integrationIds = scope.integrationIds ? scopedTargets.map((target) => target.id) : undefined;
-
-    const resultsQuery = clientApi.integration.searchMediaRequests.useQuery(
-      { query: debouncedQuery, integrationIds },
-      {
-        enabled: shouldSearch,
-        placeholderData: keepPreviousData,
-        select: (data) => data.slice(0, 10),
-      },
-    );
-
-    const isLoading = targetsQuery.isLoading || (shouldSearch && resultsQuery.isLoading);
-    const isError = targetsQuery.isError || (shouldSearch && resultsQuery.isError);
-
-    if (!targetsQuery.data) {
-      return {
-        isLoading,
-        isError,
-        data: [],
-      };
-    }
-
-    if (!hasScopedTargets) {
-      return {
-        isLoading,
-        isError,
-        data: [
-          {
-            key: "disabled",
-            kind: "disabled",
-            label: tMedia("action.search.label"),
-            description: scope.integrationIds
-              ? tMedia("action.search.disabled.scoped")
-              : tMedia("action.search.disabled.noIntegration"),
-          },
-        ],
-      };
-    }
-
-    if (debouncedQuery.length === 0) {
-      return {
-        isLoading,
-        isError,
-        data: [
-          {
-            key: "hint",
-            kind: "hint",
-            label: tMedia("action.search.label"),
-            description: tMedia("action.search.description"),
-          },
-        ],
-      };
-    }
-
-    return {
-      isLoading,
-      isError,
-      data: (resultsQuery.data ?? []).map((result) => ({
-        key: `result-${result.integration.id}-${result.type}-${result.id}`,
-        kind: "result",
-        result,
-      })),
-    };
-  },
-});

packages/spotlight/src/modes/preferences/groups.tsx

@@ -1,72 +0,0 @@
-import { Group, Text } from "@mantine/core";
-import { IconSettings } from "@tabler/icons-react";
-
-import { useSession } from "@homarr/auth/client";
-import { colorSchemes } from "@homarr/definitions";
-import { visiblePreferenceDefinitions } from "@homarr/settings";
-import { useI18n, useScopedI18n } from "@homarr/translation/client";
-
-import { createGroup } from "../../lib/group";
-import { preferenceChildrenOptionsByKey, preferenceIcons } from "../../preferences/preference-registry";
-import { settingsChildrenOptions } from "../command/children/preferences/settings-children";
-
-type PreferencesGroupOption = { key: "settings"; preferenceKey: null } | { key: string; preferenceKey: string };
-
-const settingsOption: PreferencesGroupOption = { key: "settings", preferenceKey: null };
-
-export const preferencesGroup = createGroup<PreferencesGroupOption>({
-  keyPath: "key",
-  title: (t) => t("search.mode.command.group.preferences.title"),
-  useOptions(query) {
-    const t = useI18n();
-    const tColorScheme = useScopedI18n("common.colorScheme.options");
-    const { data: session } = useSession();
-    const definitions = visiblePreferenceDefinitions(Boolean(session?.user));
-    const q = query.trim().toLowerCase();
-
-    if (q.length === 0) return [settingsOption];
-
-    const matching = definitions.flatMap((def): PreferencesGroupOption[] => {
-      if (!preferenceChildrenOptionsByKey[def.key]) return [];
-      const label = t(`search.mode.command.group.preferences.option.${def.key}.label` as never);
-      const searchValues = [
-        label,
-        ...def.aliases,
-        ...(def.key === "colorScheme" ? colorSchemes.map((s) => tColorScheme(s)) : []),
-      ];
-      if (!searchValues.some((v) => v.toLowerCase().includes(q))) return [];
-      return [{ key: def.key, preferenceKey: def.key }];
-    });
-
-    if (matching.length > 0) return matching;
-
-    const allSearchValues = [
-      t("search.mode.command.group.preferences.title"),
-      ...definitions.flatMap((d) => d.aliases),
-    ];
-    return allSearchValues.some((v) => v.toLowerCase().includes(q)) ? [settingsOption] : [];
-  },
-  Component: (option) => {
-    const t = useScopedI18n("search.mode.command.group.preferences");
-    const tOption = useScopedI18n("search.mode.command.group.preferences.option");
-    const Icon = option.preferenceKey
-      ? preferenceIcons[option.preferenceKey as keyof typeof preferenceIcons]
-      : IconSettings;
-    const label = option.preferenceKey ? tOption(`${option.preferenceKey}.label` as never) : t("title");
-
-    return (
-      <Group px="md" py="sm" wrap="nowrap" gap="sm">
-        <Icon stroke={1.5} />
-        <Text>{label}</Text>
-      </Group>
-    );
-  },
-  filter: () => true,
-  useInteraction: (option) => ({
-    type: "children",
-    ...(option.preferenceKey
-      ? (preferenceChildrenOptionsByKey[option.preferenceKey as keyof typeof preferenceChildrenOptionsByKey]?.({}) ??
-        settingsChildrenOptions({}))
-      : settingsChildrenOptions({})),
-  }),
-});

packages/spotlight/src/preferences/preference-registry.tsx

@@ -1,136 +0,0 @@
-"use client";
-
-import {
-  IconActivity,
-  IconCalendarWeek,
-  IconDeviceDesktop,
-  IconExternalLink,
-  IconHome,
-  IconLanguage,
-  IconLayoutBoard,
-  IconSearch,
-  IconSettings,
-  IconWorldWww,
-} from "@tabler/icons-react";
-import type { DayOfWeek } from "@mantine/dates";
-import dayjs from "dayjs";
-import localeData from "dayjs/plugin/localeData";
-
-import { clientApi } from "@homarr/api/client";
-import { colorSchemes } from "@homarr/definitions";
-import type { UserPreferenceKey } from "@homarr/settings";
-import { useScopedI18n } from "@homarr/translation/client";
-import type { TablerIcon } from "@homarr/ui";
-
-import { createChildrenOptions } from "../lib/children";
-import {
-  createCheckmarkPreferenceAction,
-  createLoadingPreferenceAction,
-  PreferenceDetailHeader,
-} from "../modes/command/children/preferences/action-row";
-import { createSelectablePreferenceActions } from "../modes/command/children/preferences/selectable-actions";
-import { languageChildrenOptions } from "../modes/command/children/language";
-import { useUserPreference } from "./use-user-preference";
-
-dayjs.extend(localeData);
-
-type ChildrenFactory = ReturnType<typeof createChildrenOptions<Record<string, unknown>>>;
-
-export const preferenceIcons: Record<UserPreferenceKey, TablerIcon> = {
-  colorScheme: IconDeviceDesktop,
-  locale: IconLanguage,
-  defaultSearchEngineId: IconSearch,
-  openSearchInNewTab: IconExternalLink,
-  ddgBangs: IconWorldWww,
-  firstDayOfWeek: IconCalendarWeek,
-  homeBoardId: IconHome,
-  mobileHomeBoardId: IconLayoutBoard,
-  pingIconsEnabled: IconActivity,
-  fullPreferencesPage: IconSettings,
-};
-
-const createStaticChildren = (
-  preferenceKey: UserPreferenceKey,
-  useOptions: () => Array<{ key: string; label: string; value: unknown }>,
-): ChildrenFactory =>
-  createChildrenOptions<Record<string, unknown>>({
-    useActions: () => {
-      const { value, setValue, isPending } = useUserPreference(preferenceKey);
-      return useOptions().map((opt) =>
-        createCheckmarkPreferenceAction({
-          key: opt.key,
-          label: opt.label,
-          isSelected: value === opt.value,
-          onSelect: () => setValue(opt.value as never),
-          isPending,
-        }),
-      );
-    },
-    DetailComponent: () => <PreferenceDetailHeader titleKey={`${preferenceKey}.children.detail.title`} />,
-  });
-
-const createAsyncSelectableChildren = <TItem,>(
-  preferenceKey: UserPreferenceKey,
-  useQuery: () => { data: TItem[] | undefined; isLoading: boolean },
-  mapItem: (item: TItem) => { key: string; label: string; value: string },
-  noneKey: string,
-  unavailableKey: string,
-): ChildrenFactory =>
-  createChildrenOptions<Record<string, unknown>>({
-    useActions: (_, query) => {
-      const { value, setValue, isPending } = useUserPreference(preferenceKey);
-      const result = useQuery();
-      const t = useScopedI18n("search.mode.command.group.preferences.option");
-
-      if (result.isLoading) return [createLoadingPreferenceAction()];
-
-      return createSelectablePreferenceActions({
-        query,
-        currentValue: value as string | null,
-        noneLabel: t(noneKey as never),
-        unavailableLabel: t(unavailableKey as never),
-        items: (result.data ?? []).map(mapItem),
-        onSelect: (v) => setValue(v as never),
-        isPending,
-      });
-    },
-    DetailComponent: () => <PreferenceDetailHeader titleKey={`${preferenceKey}.children.detail.title`} />,
-  });
-
-const firstDayOfWeekOptions: DayOfWeek[] = [1, 6, 0];
-
-export const preferenceChildrenOptionsByKey: Partial<Record<UserPreferenceKey, ChildrenFactory>> = {
-  colorScheme: createStaticChildren("colorScheme", () => {
-    const t = useScopedI18n("common.colorScheme.options");
-    return colorSchemes.map((s) => ({ key: s, label: t(s), value: s }));
-  }),
-  locale: languageChildrenOptions,
-  defaultSearchEngineId: createAsyncSelectableChildren(
-    "defaultSearchEngineId",
-    () => clientApi.searchEngine.getSelectable.useQuery(),
-    (e) => ({ key: e.value, label: e.label, value: e.value }),
-    "searchEngine.none",
-    "searchEngine.unavailable",
-  ),
-  firstDayOfWeek: createStaticChildren("firstDayOfWeek", () =>
-    firstDayOfWeekOptions.map((day) => ({
-      key: day.toString(),
-      label: dayjs.weekdays(false)[day] ?? day.toString(),
-      value: day,
-    })),
-  ),
-  homeBoardId: createAsyncSelectableChildren(
-    "homeBoardId",
-    () => clientApi.board.getAllBoards.useQuery(),
-    (b) => ({ key: b.id, label: b.name, value: b.id }),
-    "board.none",
-    "board.unavailable",
-  ),
-  mobileHomeBoardId: createAsyncSelectableChildren(
-    "mobileHomeBoardId",
-    () => clientApi.board.getAllBoards.useQuery(),
-    (b) => ({ key: b.id, label: b.name, value: b.id }),
-    "board.none",
-    "board.unavailable",
-  ),
-};

packages/spotlight/src/preferences/use-user-preference.ts

@@ -1,204 +0,0 @@
-"use client";
-
-import { useEffect, useMemo, useRef, useSyncExternalStore } from "react";
-import { useRouter } from "next/navigation";
-import { useMantineColorScheme } from "@mantine/core";
-import type { DayOfWeek } from "@mantine/dates";
-
-import { clientApi } from "@homarr/api/client";
-import { useSession } from "@homarr/auth/client";
-import type { ColorScheme } from "@homarr/definitions";
-import { showErrorNotification } from "@homarr/notifications";
-import type { SettingsContextProps } from "@homarr/settings/creator";
-import { userPreferenceDefinitions, userPreferenceDefinitionByKey } from "@homarr/settings";
-import type { UserPreferenceKey } from "@homarr/settings";
-import { useSettings } from "@homarr/settings";
-import { useChangeLocale, useCurrentLocale, useI18n } from "@homarr/translation/client";
-
-// --- Optimistic store (module-level, shared across all hook instances) ---
-
-const optimisticRef: { current: Partial<Record<UserPreferenceKey, unknown>> } = { current: {} };
-let optimisticVersion = 0;
-const optimisticListeners = new Set<() => void>();
-
-const notifyListeners = () => {
-  optimisticVersion += 1;
-  optimisticListeners.forEach((fn) => fn());
-};
-
-const subscribeOptimistic = (listener: () => void) => {
-  optimisticListeners.add(listener);
-  return () => optimisticListeners.delete(listener);
-};
-
-const setOptimistic = (key: UserPreferenceKey, value: unknown) => {
-  optimisticRef.current[key] = value;
-  notifyListeners();
-};
-
-const clearOptimistic = (keys: readonly UserPreferenceKey[]) => {
-  let changed = false;
-  for (const key of keys) {
-    changed ||= key in optimisticRef.current;
-    delete optimisticRef.current[key];
-  }
-  if (changed) notifyListeners();
-};
-
-const CLIENT_ONLY_GROUPS = new Set(["colorScheme", "locale"]);
-
-const isDbBacked = (key: UserPreferenceKey) => {
-  const group = userPreferenceDefinitionByKey[key].mutationGroup;
-  return group !== null && !CLIENT_ONLY_GROUPS.has(group);
-};
-
-const getGroupKeys = (key: UserPreferenceKey): UserPreferenceKey[] => {
-  const group = userPreferenceDefinitionByKey[key].mutationGroup;
-  if (!group) return [key];
-  return userPreferenceDefinitions.filter((d) => d.mutationGroup === group).map((d) => d.key);
-};
-
-// --- Hook ---
-
-export const useUserPreferences = () => {
-  const router = useRouter();
-  const settings = useSettings();
-  const settingsRef = useRef(settings);
-  settingsRef.current = settings;
-
-  const { data: session } = useSession();
-  const { colorScheme, setColorScheme } = useMantineColorScheme();
-  const currentLocale = useCurrentLocale();
-  const { changeLocale } = useChangeLocale();
-  const t = useI18n();
-  const userId = session?.user.id;
-  const pendingRef = useRef<Record<string, boolean>>({});
-  const prevUserIdRef = useRef(userId);
-
-  useEffect(() => {
-    if (prevUserIdRef.current === userId) return;
-    prevUserIdRef.current = userId;
-    clearOptimistic(userPreferenceDefinitions.map((d) => d.key));
-  }, [userId]);
-
-  useSyncExternalStore(
-    subscribeOptimistic,
-    () => optimisticVersion,
-    () => optimisticVersion,
-  );
-
-  const refresh = () => router.refresh();
-
-  const searchMutation = clientApi.user.changeSearchPreferences.useMutation({ onSuccess: refresh });
-  const homeBoardsMutation = clientApi.user.changeHomeBoards.useMutation({ onSuccess: refresh });
-  const firstDayMutation = clientApi.user.changeFirstDayOfWeek.useMutation({ onSuccess: refresh });
-  const pingMutation = clientApi.user.changePingIconsEnabled.useMutation({ onSuccess: refresh });
-
-  const getEffective = (key: UserPreferenceKey): unknown =>
-    key in optimisticRef.current ? optimisticRef.current[key] : settingsRef.current[key as keyof SettingsContextProps];
-
-  const pick = (field: UserPreferenceKey, changedKey: UserPreferenceKey, value: unknown) =>
-    field === changedKey ? value : getEffective(field);
-
-  const groupDispatchers: Record<string, (uid: string, key: UserPreferenceKey, value: unknown) => Promise<unknown>> = {
-    searchPreferences: (uid, key, value) =>
-      searchMutation.mutateAsync({
-        userId: uid,
-        defaultSearchEngineId: pick("defaultSearchEngineId", key, value) as string | null,
-        openInNewTab: pick("openSearchInNewTab", key, value) as boolean,
-        ddgBangsEnabled: pick("ddgBangs", key, value) as boolean,
-      }),
-    homeBoards: (uid, key, value) =>
-      homeBoardsMutation.mutateAsync({
-        userId: uid,
-        homeBoardId: pick("homeBoardId", key, value) as string | null,
-        mobileHomeBoardId: pick("mobileHomeBoardId", key, value) as string | null,
-      }),
-    firstDayOfWeek: (uid, _key, value) => firstDayMutation.mutateAsync({ id: uid, firstDayOfWeek: value as DayOfWeek }),
-    pingIconsEnabled: (uid, _key, value) => pingMutation.mutateAsync({ id: uid, pingIconsEnabled: value as boolean }),
-  };
-
-  const groupPending: Record<string, boolean> = {
-    searchPreferences: searchMutation.isPending,
-    homeBoards: homeBoardsMutation.isPending,
-    firstDayOfWeek: firstDayMutation.isPending,
-    pingIconsEnabled: pingMutation.isPending,
-  };
-
-  const persistedValues = useMemo<Record<UserPreferenceKey, unknown>>(() => {
-    const values: Record<string, unknown> = {
-      colorScheme: colorScheme as ColorScheme,
-      locale: currentLocale,
-      fullPreferencesPage: userId ? `/manage/users/${userId}/general` : null,
-    };
-    for (const def of userPreferenceDefinitions) {
-      if (def.key in values) continue;
-      values[def.key] = settings[def.key as keyof SettingsContextProps];
-    }
-    return values as Record<UserPreferenceKey, unknown>;
-  }, [colorScheme, currentLocale, userId, settings]);
-
-  useEffect(() => {
-    const matchedKeys = Object.entries(persistedValues)
-      .filter(([key, value]) => optimisticRef.current[key as UserPreferenceKey] === value)
-      .map(([key]) => key as UserPreferenceKey);
-    clearOptimistic(matchedKeys);
-  }, [persistedValues]);
-
-  const getValue = (key: UserPreferenceKey) =>
-    key in optimisticRef.current ? optimisticRef.current[key] : persistedValues[key];
-
-  const isPreferencePending = (key: UserPreferenceKey): boolean => {
-    const group = userPreferenceDefinitionByKey[key].mutationGroup;
-    if (!group || CLIENT_ONLY_GROUPS.has(group)) return false;
-    return (groupPending[group] ?? false) || (pendingRef.current[group] ?? false);
-  };
-
-  const clientSetters: Partial<Record<UserPreferenceKey, (value: unknown) => void>> = {
-    colorScheme: (value) => setColorScheme(value as ColorScheme),
-    locale: (value) => changeLocale(value as typeof currentLocale),
-    fullPreferencesPage: () => undefined,
-  };
-
-  const setValueAsync = async (key: UserPreferenceKey, value: unknown) => {
-    if (isDbBacked(key) && !userId) return;
-    if (isPreferencePending(key)) return;
-
-    const clientSetter = clientSetters[key];
-    if (clientSetter) {
-      clientSetter(value);
-      return;
-    }
-
-    const group = userPreferenceDefinitionByKey[key].mutationGroup;
-    if (!group) return;
-    const dispatcher = groupDispatchers[group];
-    if (!dispatcher || !userId) return;
-
-    setOptimistic(key, value);
-
-    pendingRef.current[group] = true;
-    try {
-      await dispatcher(userId, key, value);
-    } catch {
-      clearOptimistic(getGroupKeys(key));
-      showErrorNotification({
-        message: t("search.mode.command.group.preferences.notification.error.message"),
-      });
-    } finally {
-      pendingRef.current[group] = false;
-    }
-  };
-
-  return {
-    getPreference(preferenceKey: UserPreferenceKey) {
-      return {
-        value: getValue(preferenceKey),
-        setValue: (value: never) => setValueAsync(preferenceKey, value),
-        isPending: isPreferencePending(preferenceKey),
-      };
-    },
-  };
-};
-
-export const useUserPreference = (key: UserPreferenceKey) => useUserPreferences().getPreference(key);

packages/spotlight/src/spotlight-store.ts

@@ -3,17 +3,9 @@
 import { clamp } from "@mantine/hooks";
 import type { SpotlightStore } from "@mantine/spotlight";
 import { createSpotlight } from "@mantine/spotlight";
-import { atom } from "jotai";
 
 export const [spotlightStore, spotlightActions] = createSpotlight();
 
-export interface MediaRequestSearchScope {
-  integrationIds?: string[];
-}
-
-export const mediaRequestSearchScopeAtom = atom<MediaRequestSearchScope>({});
-export const mediaRequestSearchEvent = "homarr:spotlight:media-request-search";
-
 export const setSelectedAction = (index: number, store: SpotlightStore) => {
   store.updateState((state) => ({ ...state, selected: index }));
 };

packages/translation/src/lang/ca.json

@@ -132,7 +132,6 @@
       },
       "password": {
         "label": "Contrasenya",
-        "suggestionsTitle": "",
         "suggestion": {
           "length": "Inclou com a mínim 8 caràcters",
           "lowercase": "Inclou minúscules",
@@ -1406,9 +1405,6 @@
         "openNewTab": {
           "label": ""
         },
-        "withBorder": {
-          "label": ""
-        },
         "items": {
           "label": "",
           "add": ""

packages/translation/src/lang/cn.json

@@ -132,7 +132,6 @@
       },
       "password": {
         "label": "密码",
-        "suggestionsTitle": "",
         "suggestion": {
           "length": "至少包含 8 个字符",
           "lowercase": "包含小写字母",
@@ -1406,9 +1405,6 @@
         "openNewTab": {
           "label": "在新标签页中打开"
         },
-        "withBorder": {
-          "label": ""
-        },
         "items": {
           "label": "书签",
           "add": "添加书签"

packages/translation/src/lang/cr.json

@@ -132,13 +132,12 @@
       },
       "password": {
         "label": "crwdns26:0crwdne26:0",
-        "suggestionsTitle": "crwdns4261:0crwdne4261:0",
         "suggestion": {
-          "length": "crwdns4263:0crwdne4263:0",
-          "lowercase": "crwdns4265:0crwdne4265:0",
-          "uppercase": "crwdns4267:0crwdne4267:0",
-          "number": "crwdns4269:0crwdne4269:0",
-          "special": "crwdns4271:0crwdne4271:0"
+          "length": "crwdns28:0crwdne28:0",
+          "lowercase": "crwdns30:0crwdne30:0",
+          "uppercase": "crwdns32:0crwdne32:0",
+          "number": "crwdns34:0crwdne34:0",
+          "special": "crwdns36:0crwdne36:0"
         }
       },
       "passwordConfirm": {
@@ -1406,9 +1405,6 @@
         "openNewTab": {
           "label": "crwdns2686:0crwdne2686:0"
         },
-        "withBorder": {
-          "label": "crwdns4273:0crwdne4273:0"
-        },
         "items": {
           "label": "crwdns764:0crwdne764:0",
           "add": "crwdns766:0crwdne766:0"

packages/translation/src/lang/cs.json

@@ -132,7 +132,6 @@
       },
       "password": {
         "label": "Heslo",
-        "suggestionsTitle": "",
         "suggestion": {
           "length": "Obsahuje alespoň 8 znaků",
           "lowercase": "Obsahuje malé písmeno",
@@ -1406,9 +1405,6 @@
         "openNewTab": {
           "label": ""
         },
-        "withBorder": {
-          "label": ""
-        },
         "items": {
           "label": "",
           "add": ""

packages/translation/src/lang/da.json

@@ -132,7 +132,6 @@
       },
       "password": {
         "label": "Adgangskode",
-        "suggestionsTitle": "",
         "suggestion": {
           "length": "Inkluderer mindst 8 tegn",
           "lowercase": "Inkluderer små bogstaver",
@@ -1406,9 +1405,6 @@
         "openNewTab": {
           "label": "Åbn i nyt faneblad"
         },
-        "withBorder": {
-          "label": ""
-        },
         "items": {
           "label": "Bogmærker",
           "add": "Tilføj bogmærke"

packages/translation/src/lang/de-CH.json

@@ -132,7 +132,6 @@
       },
       "password": {
         "label": "Passwort",
-        "suggestionsTitle": "",
         "suggestion": {
           "length": "Enthält mindestens 8 Zeichen",
           "lowercase": "Enthält Kleinbuchstaben",
@@ -1406,9 +1405,6 @@
         "openNewTab": {
           "label": "In neuem Tab öffnen"
         },
-        "withBorder": {
-          "label": ""
-        },
         "items": {
           "label": "Lesezeichen",
           "add": "Lesezeichen hinzufügen"

packages/translation/src/lang/de.json

@@ -132,7 +132,6 @@
       },
       "password": {
         "label": "Passwort",
-        "suggestionsTitle": "",
         "suggestion": {
           "length": "Enthält mindestens 8 Zeichen",
           "lowercase": "Enthält Kleinbuchstaben",
@@ -1406,9 +1405,6 @@
         "openNewTab": {
           "label": "In neuem Tab öffnen"
         },
-        "withBorder": {
-          "label": ""
-        },
         "items": {
           "label": "Lesezeichen",
           "add": "Lesezeichen hinzufügen"

packages/translation/src/lang/el.json

@@ -132,7 +132,6 @@
       },
       "password": {
         "label": "Κωδικός",
-        "suggestionsTitle": "",
         "suggestion": {
           "length": "",
           "lowercase": "Περιλαμβάνει πεζό γράμμα",
@@ -1406,9 +1405,6 @@
         "openNewTab": {
           "label": ""
         },
-        "withBorder": {
-          "label": ""
-        },
         "items": {
           "label": "",
           "add": ""

packages/translation/src/lang/en-gb.json

@@ -132,7 +132,6 @@
       },
       "password": {
         "label": "Password",
-        "suggestionsTitle": "",
         "suggestion": {
           "length": "Includes a minimum of 8 characters",
           "lowercase": "Includes a lower-case letter",
@@ -1406,9 +1405,6 @@
         "openNewTab": {
           "label": "Open in new tab"
         },
-        "withBorder": {
-          "label": ""
-        },
         "items": {
           "label": "Bookmarks",
           "add": "Add bookmark"
@@ -4555,23 +4551,9 @@
         }
       },
       "media": {
-        "help": "Search for movies or shows to request",
         "requestMovie": "",
         "requestSeries": "",
-        "openIn": "",
-        "group": {
-          "title": "Movies and shows"
-        },
-        "action": {
-          "search": {
-            "label": "Search for movies or shows",
-            "description": "Start typing to search your media request integrations",
-            "disabled": {
-              "noIntegration": "Add an Overseerr, Jellyseerr, or Seerr integration to enable media search.",
-              "scoped": "This widget does not have an accessible media request integration."
-            }
-          }
-        }
+        "openIn": ""
       },
       "external": {
         "help": "",
@@ -4847,11 +4829,7 @@
             "table": {
               "header": {
                 "season": "Season",
-                "episodes": "Episodes",
-                "status": "Status"
-              },
-              "status": {
-                "requested": "Requested"
+                "episodes": "Episodes"
               }
             },
             "button": {

packages/translation/src/lang/en.json

@@ -1303,13 +1303,6 @@
     },
     "edit": {
       "title": "Edit item",
-      "tab": {
-        "widget": "Edit widget",
-        "app": "Edit app"
-      },
-      "app": {
-        "propagationNotice": "Changes to this app will be applied everywhere it is used across all dashboards."
-      },
       "advancedOptions": {
         "label": "Advanced options",
         "title": "Advanced item options"
@@ -4558,141 +4551,13 @@
                 "label": "Create a new group"
               }
             }
-          },
-          "preferences": {
-            "title": "Preferences",
-            "children": {
-              "detail": {
-                "title": "Select a preference to change",
-                "backHint": "Press Backspace or use the back button to go back",
-                "backAction": "Go back"
-              }
-            },
-            "notification": {
-              "error": {
-                "message": "Unable to update preference"
-              }
-            },
-            "option": {
-              "preferences": {
-                "label": "Open preferences"
-              },
-              "boolean": {
-                "enabled": "Enabled",
-                "disabled": "Disabled"
-              },
-              "board": {
-                "none": "None",
-                "unavailable": "Currently selected (unavailable)"
-              },
-              "searchEngine": {
-                "none": "None",
-                "unavailable": "Currently selected (unavailable)"
-              },
-              "colorScheme": {
-                "label": "Color scheme",
-                "children": {
-                  "detail": {
-                    "title": "Select your color scheme"
-                  }
-                }
-              },
-              "locale": {
-                "label": "Language",
-                "children": {
-                  "detail": {
-                    "title": "Select your preferred language"
-                  }
-                }
-              },
-              "defaultSearchEngineId": {
-                "label": "Default search engine",
-                "children": {
-                  "detail": {
-                    "title": "Select your default search engine"
-                  }
-                }
-              },
-              "openSearchInNewTab": {
-                "label": "Open search results in new tab",
-                "children": {
-                  "detail": {
-                    "title": "Open search results in new tab"
-                  }
-                }
-              },
-              "ddgBangs": {
-                "label": "Enable DuckDuckGo bangs",
-                "children": {
-                  "detail": {
-                    "title": "Enable DuckDuckGo bangs"
-                  }
-                }
-              },
-              "firstDayOfWeek": {
-                "label": "First day of the week",
-                "children": {
-                  "detail": {
-                    "title": "Select the first day of the week"
-                  }
-                }
-              },
-              "homeBoardId": {
-                "label": "Home board",
-                "children": {
-                  "detail": {
-                    "title": "Select your home board"
-                  }
-                }
-              },
-              "mobileHomeBoardId": {
-                "label": "Mobile home board",
-                "children": {
-                  "detail": {
-                    "title": "Select your mobile home board"
-                  }
-                }
-              },
-              "pingIconsEnabled": {
-                "label": "Use icons for pings",
-                "children": {
-                  "detail": {
-                    "title": "Use icons for pings"
-                  }
-                }
-              },
-              "fullPreferencesPage": {
-                "label": "Open full preferences page"
-              }
-            }
           }
         }
       },
       "media": {
-        "help": "Search for movies or shows to request",
         "requestMovie": "Request movie",
         "requestSeries": "Request series",
-        "openIn": "Open in {kind}",
-        "group": {
-          "title": "Movies and shows"
-        },
-        "action": {
-          "search": {
-            "label": "Search for movies or shows",
-            "description": "Start typing to search your media request integrations",
-            "disabled": {
-              "noIntegration": "Add an Overseerr, Jellyseerr, or Seerr integration to enable media search.",
-              "scoped": "This widget does not have an accessible media request integration."
-            }
-          }
-        },
-        "availability": {
-          "available": "Available",
-          "partiallyAvailable": "Partial",
-          "processing": "Processing",
-          "requested": "Requested",
-          "pending": "Requested"
-        }
+        "openIn": "Open in {kind}"
       },
       "external": {
         "help": "Use an external search engine",
@@ -4968,11 +4833,7 @@
             "table": {
               "header": {
                 "season": "Season",
-                "episodes": "Episodes",
-                "status": "Status"
-              },
-              "status": {
-                "requested": "Requested"
+                "episodes": "Episodes"
               }
             },
             "button": {

packages/translation/src/lang/es.json

@@ -132,7 +132,6 @@
       },
       "password": {
         "label": "Contraseña",
-        "suggestionsTitle": "",
         "suggestion": {
           "length": "Incluye al menos 8 caracteres",
           "lowercase": "Incluye al menos una letra minúscula",
@@ -1406,9 +1405,6 @@
         "openNewTab": {
           "label": "Abrir en una nueva pestaña"
         },
-        "withBorder": {
-          "label": ""
-        },
         "items": {
           "label": "Marcadores",
           "add": "Añadir marcador"

packages/translation/src/lang/et.json

@@ -132,7 +132,6 @@
       },
       "password": {
         "label": "",
-        "suggestionsTitle": "",
         "suggestion": {
           "length": "",
           "lowercase": "",
@@ -1406,9 +1405,6 @@
         "openNewTab": {
           "label": ""
         },
-        "withBorder": {
-          "label": ""
-        },
         "items": {
           "label": "",
           "add": ""

packages/translation/src/lang/fr.json

@@ -132,7 +132,6 @@
       },
       "password": {
         "label": "Mot de passe",
-        "suggestionsTitle": "",
         "suggestion": {
           "length": "Contient au moins 8 caractères",
           "lowercase": "Inclut une lettre minuscule",
@@ -1406,9 +1405,6 @@
         "openNewTab": {
           "label": "Ouvrir dans un nouvel onglet"
         },
-        "withBorder": {
-          "label": ""
-        },
         "items": {
           "label": "Signets",
           "add": "Ajouter un signet"
@@ -2092,7 +2088,7 @@
         "empty": "",
         "user": "Utilisateur",
         "media": "Média",
-        "state": "État",
+        "state": "",
         "quality": "Qualité",
         "device": "Appareil",
         "progress": "Progression",

packages/translation/src/lang/he.json

@@ -132,7 +132,6 @@
       },
       "password": {
         "label": "סיסמה",
-        "suggestionsTitle": "",
         "suggestion": {
           "length": "כולל לפחות 8 תווים",
           "lowercase": "אפשר אותיות קטנות",
@@ -1406,9 +1405,6 @@
         "openNewTab": {
           "label": "פתיחה בכרטיסיה חדשה"
         },
-        "withBorder": {
-          "label": ""
-        },
         "items": {
           "label": "סימניות",
           "add": "הוסף סימניה"

packages/translation/src/lang/hr.json

@@ -132,7 +132,6 @@
       },
       "password": {
         "label": "Lozinka",
-        "suggestionsTitle": "",
         "suggestion": {
           "length": "",
           "lowercase": "Uključuje mala slova",
@@ -1406,9 +1405,6 @@
         "openNewTab": {
           "label": ""
         },
-        "withBorder": {
-          "label": ""
-        },
         "items": {
           "label": "",
           "add": ""

packages/translation/src/lang/hu.json

@@ -132,7 +132,6 @@
       },
       "password": {
         "label": "Jelszó",
-        "suggestionsTitle": "",
         "suggestion": {
           "length": "Tartalmazzon legalább 8 karaktert",
           "lowercase": "Tartalmazzon kisbetűt",
@@ -1406,9 +1405,6 @@
         "openNewTab": {
           "label": "Megnyitás új lapon"
         },
-        "withBorder": {
-          "label": ""
-        },
         "items": {
           "label": "Könyjelzők",
           "add": "Könyvjelző hozzáadása"

packages/translation/src/lang/it.json

@@ -132,7 +132,6 @@
       },
       "password": {
         "label": "Password",
-        "suggestionsTitle": "Suggerimenti password",
         "suggestion": {
           "length": "Include almeno 8 caratteri",
           "lowercase": "Include lettera minuscola",
@@ -1406,9 +1405,6 @@
         "openNewTab": {
           "label": "Apri in una nuova scheda"
         },
-        "withBorder": {
-          "label": "Mostra bordo"
-        },
         "items": {
           "label": "Segnalibri",
           "add": "Aggiungi segnalibro"

packages/translation/src/lang/ja.json

@@ -132,7 +132,6 @@
       },
       "password": {
         "label": "パスワード",
-        "suggestionsTitle": "",
         "suggestion": {
           "length": "少なくとも 8 文字以上を含む",
           "lowercase": "小文字を含む",
@@ -1406,9 +1405,6 @@
         "openNewTab": {
           "label": "新しいタブで開く"
         },
-        "withBorder": {
-          "label": ""
-        },
         "items": {
           "label": "ブックマーク",
           "add": "ブックマークに追加"

packages/translation/src/lang/ko.json

@@ -132,7 +132,6 @@
       },
       "password": {
         "label": "비밀번호",
-        "suggestionsTitle": "",
         "suggestion": {
           "length": "",
           "lowercase": "소문자 포함",
@@ -1406,9 +1405,6 @@
         "openNewTab": {
           "label": ""
         },
-        "withBorder": {
-          "label": ""
-        },
         "items": {
           "label": "",
           "add": ""

packages/translation/src/lang/lt.json

@@ -132,7 +132,6 @@
       },
       "password": {
         "label": "Slaptažodis",
-        "suggestionsTitle": "",
         "suggestion": {
           "length": "",
           "lowercase": "",
@@ -1406,9 +1405,6 @@
         "openNewTab": {
           "label": ""
         },
-        "withBorder": {
-          "label": ""
-        },
         "items": {
           "label": "",
           "add": ""

packages/translation/src/lang/lv.json

@@ -132,7 +132,6 @@
       },
       "password": {
         "label": "Parole",
-        "suggestionsTitle": "",
         "suggestion": {
           "length": "",
           "lowercase": "Ietver mazo burtu",
@@ -1406,9 +1405,6 @@
         "openNewTab": {
           "label": ""
         },
-        "withBorder": {
-          "label": ""
-        },
         "items": {
           "label": "",
           "add": ""

packages/translation/src/lang/nl.json

@@ -132,7 +132,6 @@
       },
       "password": {
         "label": "Wachtwoord",
-        "suggestionsTitle": "",
         "suggestion": {
           "length": "Bevat ten minste 8 tekens",
           "lowercase": "Inclusief kleine letter",
@@ -1406,9 +1405,6 @@
         "openNewTab": {
           "label": "In nieuw tabblad openen"
         },
-        "withBorder": {
-          "label": ""
-        },
         "items": {
           "label": "Bladwijzers",
           "add": "Bladwijzer toevoegen"

packages/translation/src/lang/no.json

@@ -132,7 +132,6 @@
       },
       "password": {
         "label": "Passord",
-        "suggestionsTitle": "",
         "suggestion": {
           "length": "Inkluderer minst 8 tegn",
           "lowercase": "Inkluderer liten bokstav",
@@ -1406,9 +1405,6 @@
         "openNewTab": {
           "label": "Åpne i ny fane"
         },
-        "withBorder": {
-          "label": ""
-        },
         "items": {
           "label": "Bokmerke",
           "add": "Legg til bokmerke"

packages/translation/src/lang/pl.json

@@ -132,7 +132,6 @@
       },
       "password": {
         "label": "Hasło",
-        "suggestionsTitle": "",
         "suggestion": {
           "length": "Zawiera co najmniej 8 znaków",
           "lowercase": "Zawiera małą literę",
@@ -1406,9 +1405,6 @@
         "openNewTab": {
           "label": "Otwórz w nowej karcie"
         },
-        "withBorder": {
-          "label": ""
-        },
         "items": {
           "label": "Zakładki",
           "add": "Dodaj zakładkę"

packages/translation/src/lang/pt-br.json

@@ -132,7 +132,6 @@
       },
       "password": {
         "label": "Senha",
-        "suggestionsTitle": "",
         "suggestion": {
           "length": "Inclua pelo menos 8 caracteres",
           "lowercase": "Inclui letras minúsculas",
@@ -1057,7 +1056,7 @@
       }
     },
     "noResults": {
-      "title": "Nenhuma mídia enviada"
+      "title": ""
     }
   },
   "common": {
@@ -1089,8 +1088,8 @@
       "checkLogs": "Verifique os logs para mais detalhes",
       "tryAgain": "Tente novamente",
       "loading": "Carregando",
-      "show": "Mostrar",
-      "hide": "Esconder"
+      "show": "",
+      "hide": ""
     },
     "here": "aqui",
     "iconPicker": {
@@ -1256,7 +1255,7 @@
         "label": {
           "create": "Nova categoria",
           "changePosition": "Mudar de posição",
-          "settings": "Configurações"
+          "settings": ""
         }
       },
       "openAllInNewTabs": {
@@ -1406,9 +1405,6 @@
         "openNewTab": {
           "label": "Abrir em nova guia"
         },
-        "withBorder": {
-          "label": ""
-        },
         "items": {
           "label": "Marcadores",
           "add": "Adicionar marcador"
@@ -3463,7 +3459,7 @@
           "private": "Este quadro é privado"
         },
         "noResults": {
-          "title": "Nenhum painel ainda"
+          "title": ""
         },
         "modal": {
           "createBoard": {

packages/translation/src/lang/pt.json

@@ -132,7 +132,6 @@
       },
       "password": {
         "label": "",
-        "suggestionsTitle": "",
         "suggestion": {
           "length": "",
           "lowercase": "",
@@ -1406,9 +1405,6 @@
         "openNewTab": {
           "label": ""
         },
-        "withBorder": {
-          "label": ""
-        },
         "items": {
           "label": "",
           "add": ""

packages/translation/src/lang/ro.json

@@ -132,7 +132,6 @@
       },
       "password": {
         "label": "Parola",
-        "suggestionsTitle": "",
         "suggestion": {
           "length": "",
           "lowercase": "Să includă litere mici",
@@ -1406,9 +1405,6 @@
         "openNewTab": {
           "label": ""
         },
-        "withBorder": {
-          "label": ""
-        },
         "items": {
           "label": "",
           "add": ""

packages/translation/src/lang/ru.json

@@ -132,7 +132,6 @@
       },
       "password": {
         "label": "Пароль",
-        "suggestionsTitle": "",
         "suggestion": {
           "length": "Содержит не менее 8 символов",
           "lowercase": "Содержит строчную букву",
@@ -1406,9 +1405,6 @@
         "openNewTab": {
           "label": "Открывать в новой вкладке"
         },
-        "withBorder": {
-          "label": ""
-        },
         "items": {
           "label": "Закладки",
           "add": "Добавить закладку"

packages/translation/src/lang/sk.json

@@ -132,7 +132,6 @@
       },
       "password": {
         "label": "Heslo",
-        "suggestionsTitle": "",
         "suggestion": {
           "length": "Obsahuje aspoň 8 znakov",
           "lowercase": "Zahŕňa malé písmeno",
@@ -1406,9 +1405,6 @@
         "openNewTab": {
           "label": "Otvoriť na novej karte"
         },
-        "withBorder": {
-          "label": ""
-        },
         "items": {
           "label": "Záložky",
           "add": "Pridať záložku"

packages/translation/src/lang/sl.json

@@ -132,7 +132,6 @@
       },
       "password": {
         "label": "Geslo",
-        "suggestionsTitle": "",
         "suggestion": {
           "length": "",
           "lowercase": "Vključuje male črke",
@@ -1406,9 +1405,6 @@
         "openNewTab": {
           "label": ""
         },
-        "withBorder": {
-          "label": ""
-        },
         "items": {
           "label": "",
           "add": ""

packages/translation/src/lang/sv.json

@@ -132,7 +132,6 @@
       },
       "password": {
         "label": "Lösenord",
-        "suggestionsTitle": "",
         "suggestion": {
           "length": "Använd minst 8 tecken",
           "lowercase": "Använd liten bokstav",
@@ -1406,9 +1405,6 @@
         "openNewTab": {
           "label": "Öppna i en ny flik"
         },
-        "withBorder": {
-          "label": ""
-        },
         "items": {
           "label": "Bokmärken",
           "add": "Addera bokmärke"

packages/translation/src/lang/tr.json

@@ -132,7 +132,6 @@
       },
       "password": {
         "label": "Şifre",
-        "suggestionsTitle": "",
         "suggestion": {
           "length": "En az 8 karakter içermeli",
           "lowercase": "Küçük harf içermeli",
@@ -1406,9 +1405,6 @@
         "openNewTab": {
           "label": "Yeni sekmede aç"
         },
-        "withBorder": {
-          "label": ""
-        },
         "items": {
           "label": "Yer İmleri",
           "add": "Yer imi ekle"

packages/translation/src/lang/uk.json

@@ -132,7 +132,6 @@
       },
       "password": {
         "label": "Пароль",
-        "suggestionsTitle": "",
         "suggestion": {
           "length": "Включає принаймні 8 символів",
           "lowercase": "Включає малу літеру",
@@ -1406,9 +1405,6 @@
         "openNewTab": {
           "label": "Відкрити в новій вкладці"
         },
-        "withBorder": {
-          "label": ""
-        },
         "items": {
           "label": "Закладки",
           "add": "Додати закладку"

packages/translation/src/lang/vi.json

@@ -132,7 +132,6 @@
       },
       "password": {
         "label": "Mật khẩu",
-        "suggestionsTitle": "",
         "suggestion": {
           "length": "Bao gồm ít nhất 8 kí tự",
           "lowercase": "Bao gồm chữ thường",
@@ -1406,9 +1405,6 @@
         "openNewTab": {
           "label": ""
         },
-        "withBorder": {
-          "label": ""
-        },
         "items": {
           "label": "",
           "add": ""

packages/translation/src/lang/zh.json

@@ -132,7 +132,6 @@
       },
       "password": {
         "label": "密碼",
-        "suggestionsTitle": "",
         "suggestion": {
           "length": "至少包含 8 個字符",
           "lowercase": "包含小寫字母",
@@ -1406,9 +1405,6 @@
         "openNewTab": {
           "label": "於新分頁開啟"
         },
-        "withBorder": {
-          "label": ""
-        },
         "items": {
           "label": "書籤",
           "add": "新增書籤"

packages/widgets/src/index.tsx

@@ -1,7 +1,7 @@
 import type { ComponentType } from "react";
 import type { Loader } from "next/dynamic";
 import dynamic from "next/dynamic";
-import { Center, Loader as UiLoader } from "@mantine/core";
+import { Skeleton } from "@mantine/core";
 
 import { objectEntries } from "@homarr/common";
 import type { IntegrationKind, WidgetKind } from "@homarr/definitions";
@@ -107,11 +107,7 @@ export const loadWidgetDynamic = <TKind extends WidgetKind>(kind: TKind) => {
   const newlyLoadedComponent = dynamic<WidgetComponentProps<TKind>>(
     widgetImports[kind].componentLoader as Loader<WidgetComponentProps<TKind>>,
     {
-      loading: () => (
-        <Center w="100%" h="100%">
-          <UiLoader />
-        </Center>
-      ),
+      loading: () => <Skeleton w="100%" h="100%" radius="md" animate />,
     },
   );
 

packages/widgets/src/media-requests/list/component.tsx

@@ -1,32 +1,17 @@
 "use client";
 
-import {
-  ActionIcon,
-  Anchor,
-  Avatar,
-  Badge,
-  Box,
-  Card,
-  Group,
-  Image,
-  ScrollArea,
-  Stack,
-  Text,
-  Tooltip,
-} from "@mantine/core";
-import { IconSearch, IconThumbDown, IconThumbUp } from "@tabler/icons-react";
+import { ActionIcon, Anchor, Avatar, Badge, Card, Group, Image, ScrollArea, Stack, Text, Tooltip } from "@mantine/core";
+import { IconThumbDown, IconThumbUp } from "@tabler/icons-react";
 
 import type { RouterInputs, RouterOutputs } from "@homarr/api";
 import { clientApi } from "@homarr/api/client";
 import { useRequiredBoard } from "@homarr/boards/context";
 import type { MediaRequestStatus } from "@homarr/integrations/types";
 import { mediaAvailabilityConfiguration, mediaRequestStatusConfiguration } from "@homarr/integrations/types";
-import { openMediaRequestSearch } from "@homarr/spotlight";
 import { useScopedI18n } from "@homarr/translation/client";
 
 import type { WidgetComponentProps } from "../../definition";
 import { NoIntegrationDataError } from "../../errors/no-data-integration";
-import classes from "../search-button.module.css";
 
 export default function MediaServerWidget({
   integrationIds,
@@ -58,7 +43,7 @@ export default function MediaServerWidget({
           const newData = filteredData.concat(
             data.requests.map((request) => ({ ...request, integrationId: data.integrationId })),
           );
-          return newData.toSorted((dataA, dataB) => {
+          return newData.sort((dataA, dataB) => {
             if (dataA.status === dataB.status) {
               return dataB.createdAt.getTime() - dataA.createdAt.getTime();
             }
@@ -76,46 +61,25 @@ export default function MediaServerWidget({
   if (mediaRequests.length === 0) throw new NoIntegrationDataError();
 
   return (
-    <Box className={classes.searchRoot}>
-      {!isEditMode && <MediaRequestSearchButton integrationIds={integrationIds} />}
-      <ScrollArea
-        className="mediaRequests-list-scrollArea"
-        scrollbarSize="md"
-        style={{ pointerEvents: isEditMode ? "none" : undefined }}
-      >
-        <Stack className="mediaRequests-list-list" gap="xs" p="sm">
-          {mediaRequests.map((mediaRequest) => (
-            <MediaRequestCard
-              key={`${mediaRequest.integrationId}-${mediaRequest.id}`}
-              request={mediaRequest}
-              isTiny={width <= 256}
-              options={options}
-            />
-          ))}
-        </Stack>
-      </ScrollArea>
-    </Box>
+    <ScrollArea
+      className="mediaRequests-list-scrollArea"
+      scrollbarSize="md"
+      style={{ pointerEvents: isEditMode ? "none" : undefined }}
+    >
+      <Stack className="mediaRequests-list-list" gap="xs" p="sm">
+        {mediaRequests.map((mediaRequest) => (
+          <MediaRequestCard
+            key={`${mediaRequest.integrationId}-${mediaRequest.id}`}
+            request={mediaRequest}
+            isTiny={width <= 256}
+            options={options}
+          />
+        ))}
+      </Stack>
+    </ScrollArea>
   );
 }
 
-const MediaRequestSearchButton = ({ integrationIds }: { integrationIds: string[] }) => {
-  const t = useScopedI18n("search.mode.media");
-
-  return (
-    <Tooltip label={t("action.search.label")}>
-      <ActionIcon
-        className={classes.searchButton}
-        variant="light"
-        size="sm"
-        aria-label={t("action.search.label")}
-        onClick={() => openMediaRequestSearch({ integrationIds })}
-      >
-        <IconSearch size={16} />
-      </ActionIcon>
-    </Tooltip>
-  );
-};
-
 interface MediaRequestCardProps {
   request: RouterOutputs["widget"]["mediaRequests"]["getLatestRequests"][number];
   isTiny: boolean;

packages/widgets/src/media-requests/search-button.module.css

@@ -1,24 +0,0 @@
-.searchRoot {
-  position: relative;
-  height: 100%;
-}
-
-.searchButton {
-  position: absolute;
-  top: var(--mantine-spacing-xs);
-  right: var(--mantine-spacing-xs);
-  z-index: 2;
-  opacity: 0;
-  transition: opacity 120ms ease;
-}
-
-.searchRoot:hover .searchButton,
-.searchRoot:focus-within .searchButton {
-  opacity: 1;
-}
-
-@media (hover: none) {
-  .searchButton {
-    opacity: 1;
-  }
-}

packages/widgets/src/media-requests/stats/component.tsx

@@ -1,6 +1,6 @@
 "use client";
 
-import { ActionIcon, Avatar, Box, Card, Grid, Group, Stack, Text, Tooltip } from "@mantine/core";
+import { Avatar, Card, Grid, Group, Stack, Text, Tooltip } from "@mantine/core";
 import type { Icon } from "@tabler/icons-react";
 import {
   IconDeviceTv,
@@ -9,7 +9,6 @@ import {
   IconMovie,
   IconPlayerPlay,
   IconReceipt,
-  IconSearch,
   IconThumbDown,
   IconThumbUp,
 } from "@tabler/icons-react";
@@ -18,13 +17,11 @@ import combineClasses from "clsx";
 import { clientApi } from "@homarr/api/client";
 import { useRequiredBoard } from "@homarr/boards/context";
 import type { RequestStats } from "@homarr/integrations/types";
-import { openMediaRequestSearch } from "@homarr/spotlight";
 import { useScopedI18n } from "@homarr/translation/client";
 
 import type { WidgetComponentProps } from "../../definition";
 import { NoIntegrationDataError } from "../../errors/no-data-integration";
 import classes from "./component.module.css";
-import searchClasses from "../search-button.module.css";
 
 const OVERSEERR_COLOR = "#ECB000";
 const JELLYSEERR_COLOR = "#6677CC";
@@ -96,104 +93,83 @@ export default function MediaServerWidget({
   const isTiny = width < 256;
 
   return (
-    <Box className={searchClasses.searchRoot}>
-      {!isEditMode && <MediaRequestSearchButton integrationIds={integrationIds} />}
-      <Stack
-        className="mediaRequests-stats-layout"
-        h="100%"
-        gap="xs"
-        p="sm"
-        align="center"
-        justify="space-between"
-        style={{ pointerEvents: isEditMode ? "none" : undefined }}
-      >
-        <Stack gap={4} w="100%">
-          <Text className="mediaRequests-stats-stats-title" fw="bold" ta="center" size={isTiny ? "xs" : "sm"}>
-            {t("titles.stats.main")}
-          </Text>
-          <Grid className="mediaRequests-stats-stats-grid" gap={4} w="100%">
-            {data.map((stat) => (
-              <Grid.Col
-                className={combineClasses("mediaRequests-stats-stat-wrapper", `mediaRequests-stats-stat-${stat.name}`)}
-                key={stat.name}
-                span={isTiny ? 6 : 3}
-              >
-                <Tooltip label={t(`titles.stats.${stat.name}`)}>
-                  <Card p={0} radius={board.itemRadius} className={classes.card}>
-                    <Group className="mediaRequests-stats-stat-stack" justify="center" align="center" gap="xs" w="100%">
-                      <stat.icon className="mediaRequests-stats-stat-icon" size={16} />
-                      <Text className="mediaRequests-stats-stat-value" size="md">
-                        {stat.number}
-                      </Text>
-                    </Group>
-                  </Card>
-                </Tooltip>
-              </Grid.Col>
-            ))}
-          </Grid>
-        </Stack>
-        <Stack gap={4} w="100%">
-          <Text className="mediaRequests-stats-users-title" fw="bold" ta="center" size={isTiny ? "xs" : "sm"}>
-            {t("titles.users.main")} ({t("titles.users.requests")})
-          </Text>
-          <Stack className="mediaRequests-stats-users-wrapper" flex={1} w="100%" gap={4} style={{ overflow: "hidden" }}>
-            {requestStats.users.slice(0, 10).map((user) => (
-              <Card
-                component="a"
-                href={user.link}
-                target="_blank"
-                rel="noopener noreferrer"
-                className={combineClasses(
-                  "mediaRequests-stats-users-user-wrapper",
-                  `mediaRequests-stats-users-user-${user.id}`,
-                  classes.card,
-                )}
-                key={user.id}
-                p="xs"
-                radius={board.itemRadius}
-              >
-                <Group className="mediaRequests-stats-users-user-group" h="100%" p={0} gap="sm" justify="space-between">
-                  <Group gap={4}>
-                    <Tooltip label={user.integration.name}>
-                      <Avatar
-                        className="mediaRequests-stats-users-user-avatar"
-                        size={20}
-                        src={user.avatar}
-                        bd={`2px solid ${user.integration.kind === "overseerr" ? OVERSEERR_COLOR : JELLYSEERR_COLOR}`}
-                      />
-                    </Tooltip>
-                    <Text className="mediaRequests-stats-users-user-userName" size="sm">
-                      {user.displayName}
+    <Stack
+      className="mediaRequests-stats-layout"
+      h="100%"
+      gap="xs"
+      p="sm"
+      align="center"
+      justify="space-between"
+      style={{ pointerEvents: isEditMode ? "none" : undefined }}
+    >
+      <Stack gap={4} w="100%">
+        <Text className="mediaRequests-stats-stats-title" fw="bold" ta="center" size={isTiny ? "xs" : "sm"}>
+          {t("titles.stats.main")}
+        </Text>
+        <Grid className="mediaRequests-stats-stats-grid" gap={4} w="100%">
+          {data.map((stat) => (
+            <Grid.Col
+              className={combineClasses("mediaRequests-stats-stat-wrapper", `mediaRequests-stats-stat-${stat.name}`)}
+              key={stat.name}
+              span={isTiny ? 6 : 3}
+            >
+              <Tooltip label={t(`titles.stats.${stat.name}`)}>
+                <Card p={0} radius={board.itemRadius} className={classes.card}>
+                  <Group className="mediaRequests-stats-stat-stack" justify="center" align="center" gap="xs" w="100%">
+                    <stat.icon className="mediaRequests-stats-stat-icon" size={16} />
+                    <Text className="mediaRequests-stats-stat-value" size="md">
+                      {stat.number}
                     </Text>
                   </Group>
-
-                  <Text className="mediaRequests-stats-users-user-request-count" size="md" fw={500}>
-                    {user.requestCount}
+                </Card>
+              </Tooltip>
+            </Grid.Col>
+          ))}
+        </Grid>
+      </Stack>
+      <Stack gap={4} w="100%">
+        <Text className="mediaRequests-stats-users-title" fw="bold" ta="center" size={isTiny ? "xs" : "sm"}>
+          {t("titles.users.main")} ({t("titles.users.requests")})
+        </Text>
+        <Stack className="mediaRequests-stats-users-wrapper" flex={1} w="100%" gap={4} style={{ overflow: "hidden" }}>
+          {requestStats.users.slice(0, 10).map((user) => (
+            <Card
+              component="a"
+              href={user.link}
+              target="_blank"
+              rel="noopener noreferrer"
+              className={combineClasses(
+                "mediaRequests-stats-users-user-wrapper",
+                `mediaRequests-stats-users-user-${user.id}`,
+                classes.card,
+              )}
+              key={user.id}
+              p="xs"
+              radius={board.itemRadius}
+            >
+              <Group className="mediaRequests-stats-users-user-group" h="100%" p={0} gap="sm" justify="space-between">
+                <Group gap={4}>
+                  <Tooltip label={user.integration.name}>
+                    <Avatar
+                      className="mediaRequests-stats-users-user-avatar"
+                      size={20}
+                      src={user.avatar}
+                      bd={`2px solid ${user.integration.kind === "overseerr" ? OVERSEERR_COLOR : JELLYSEERR_COLOR}`}
+                    />
+                  </Tooltip>
+                  <Text className="mediaRequests-stats-users-user-userName" size="sm">
+                    {user.displayName}
                   </Text>
                 </Group>
-              </Card>
-            ))}
-          </Stack>
+
+                <Text className="mediaRequests-stats-users-user-request-count" size="md" fw={500}>
+                  {user.requestCount}
+                </Text>
+              </Group>
+            </Card>
+          ))}
         </Stack>
       </Stack>
-    </Box>
+    </Stack>
   );
 }
-
-const MediaRequestSearchButton = ({ integrationIds }: { integrationIds: string[] }) => {
-  const t = useScopedI18n("search.mode.media");
-
-  return (
-    <Tooltip label={t("action.search.label")}>
-      <ActionIcon
-        className={searchClasses.searchButton}
-        variant="light"
-        size="sm"
-        aria-label={t("action.search.label")}
-        onClick={() => openMediaRequestSearch({ integrationIds })}
-      >
-        <IconSearch size={16} />
-      </ActionIcon>
-    </Tooltip>
-  );
-};

packages/widgets/src/modals/embedded-app-edit-form.tsx

@@ -1,95 +0,0 @@
-"use client";
-
-import { useImperativeHandle, useRef } from "react";
-import { Alert, Button, Center, Loader, Stack, Text } from "@mantine/core";
-import { IconInfoCircle } from "@tabler/icons-react";
-
-import { clientApi } from "@homarr/api/client";
-import type { AppFormHandle } from "@homarr/forms-collection";
-import { AppForm } from "@homarr/forms-collection";
-import { showErrorNotification, showSuccessNotification } from "@homarr/notifications";
-import { useI18n } from "@homarr/translation/client";
-
-export interface EmbeddedAppEditFormHandle {
-  submitIfDirty: () => Promise<boolean>;
-}
-
-interface EmbeddedAppEditFormProps {
-  appId: string;
-  handleRef: React.Ref<EmbeddedAppEditFormHandle>;
-}
-
-export const EmbeddedAppEditForm = ({ appId, handleRef }: EmbeddedAppEditFormProps) => {
-  const t = useI18n();
-  const utils = clientApi.useUtils();
-  const appFormRef = useRef<AppFormHandle>(null);
-  const { data: app, isPending: isLoadingApp, isError, refetch } = clientApi.app.byId.useQuery({ id: appId });
-
-  const { mutateAsync, isPending: isMutating } = clientApi.app.update.useMutation({
-    onSuccess: async () => {
-      await utils.app.invalidate();
-      showSuccessNotification({
-        title: t("app.page.edit.notification.success.title"),
-        message: t("app.page.edit.notification.success.message"),
-      });
-    },
-    onError: () => {
-      showErrorNotification({
-        title: t("app.page.edit.notification.error.title"),
-        message: t("app.page.edit.notification.error.message"),
-      });
-    },
-  });
-
-  useImperativeHandle(
-    handleRef,
-    () => ({
-      submitIfDirty: async () => {
-        if (!appFormRef.current?.isDirty()) {
-          return true;
-        }
-
-        return appFormRef.current.submit();
-      },
-    }),
-    [],
-  );
-
-  if (isLoadingApp) {
-    return (
-      <Center py="xl">
-        <Loader />
-      </Center>
-    );
-  }
-
-  if (isError || !app) {
-    return (
-      <Stack align="center" gap="md" py="xl">
-        <Text c="dimmed">{t("app.action.select.notFound")}</Text>
-        <Button variant="light" onClick={() => void refetch()}>
-          {t("common.action.tryAgain")}
-        </Button>
-      </Stack>
-    );
-  }
-
-  return (
-    <Stack>
-      <Alert icon={<IconInfoCircle size={16} />} color="blue" variant="light">
-        {t("item.edit.app.propagationNotice")}
-      </Alert>
-      <AppForm
-        formRef={appFormRef}
-        hideButtons
-        showBackToOverview={false}
-        buttonLabels={{ submit: "" }}
-        initialValues={app}
-        handleSubmit={async (values) => {
-          await mutateAsync({ id: appId, ...values });
-        }}
-        isPending={isMutating}
-      />
-    </Stack>
-  );
-};

packages/widgets/src/modals/widget-edit-modal.tsx

@@ -1,13 +1,11 @@
 "use client";
 
-import { useRef, useState } from "react";
-import type { FormEvent } from "react";
-import { Button, Group, Stack, Tabs } from "@mantine/core";
+import { useState } from "react";
+import { Button, Group, Stack } from "@mantine/core";
 import { schemaResolver } from "@mantine/form";
 import { z } from "zod/v4";
 
 import { objectEntries } from "@homarr/common";
-import { useSession } from "@homarr/auth/client";
 import type { WidgetKind } from "@homarr/definitions";
 import { createModal, useModalAction } from "@homarr/modals";
 import type { SettingsContextProps } from "@homarr/settings/creator";
@@ -22,8 +20,6 @@ import type { OptionsBuilderResult } from "../options";
 import type { IntegrationSelectOption } from "../widget-integration-select";
 import { WidgetIntegrationSelect } from "../widget-integration-select";
 import { WidgetAdvancedOptionsModal } from "./widget-advanced-options-modal";
-import type { EmbeddedAppEditFormHandle } from "./embedded-app-edit-form";
-import { EmbeddedAppEditForm } from "./embedded-app-edit-form";
 
 export interface WidgetEditModalState {
   options: Record<string, unknown>;
@@ -38,16 +34,13 @@ interface ModalProps<TSort extends WidgetKind> {
   integrationData: IntegrationSelectOption[];
   integrationSupport: boolean;
   settings: SettingsContextProps;
-  appId?: string;
 }
 
 export const WidgetEditModal = createModal<ModalProps<WidgetKind>>(({ actions, innerProps }) => {
   const t = useI18n();
-  const { data: session } = useSession();
   const [advancedOptions, setAdvancedOptions] = useState<BoardItemAdvancedOptions>(innerProps.value.advancedOptions);
-  const appEditRef = useRef<EmbeddedAppEditFormHandle>(null);
-  const [isSubmitting, setIsSubmitting] = useState(false);
 
+  // Translate the error messages
   z.config({
     customError: zodErrorMap(t),
   });
@@ -84,128 +77,78 @@ export const WidgetEditModal = createModal<ModalProps<WidgetKind>>(({ actions, i
   });
   const { openModal } = useModalAction(WidgetAdvancedOptionsModal);
 
-  const canModifyApps = session?.user.permissions.includes("app-modify-all") ?? false;
-  const appId = innerProps.appId;
-  const showAppTab = innerProps.kind === "app" && canModifyApps && Boolean(appId);
-
-  const handleSubmit = form.onSubmit(async (values) => {
-    setIsSubmitting(true);
-    try {
-      const appSaved = showAppTab ? await (appEditRef.current?.submitIfDirty() ?? true) : true;
-
-      if (!appSaved) {
-        return;
-      }
-
-      innerProps.onSuccessfulEdit({
-        ...values,
-        advancedOptions,
-      });
-      actions.closeModal();
-    } finally {
-      setIsSubmitting(false);
-    }
-  });
-
-  const onFormSubmit = (event: FormEvent<HTMLFormElement>) => {
-    handleSubmit(event);
-  };
-
-  const widgetFormContent = (
-    <Stack>
-      {innerProps.integrationSupport && (
-        <WidgetIntegrationSelect
-          label={t("item.edit.field.integrations.label")}
-          data={innerProps.integrationData}
-          {...form.getInputProps("integrationIds")}
-        />
-      )}
-      {Object.entries(options).map(([key, value]) => {
-        const Input = getInputForType(value.type);
-
-        if (
-          !Input ||
-          value.shouldHide?.(
-            form.values.options as never,
-            innerProps.integrationData
-              .filter(({ id }) => form.values.integrationIds.includes(id))
-              .map(({ kind }) => kind),
-          )
-        ) {
-          return null;
-        }
-
-        return (
-          <Input
-            key={key}
-            kind={innerProps.kind}
-            property={key}
-            options={value as never}
-            initialOptions={innerProps.value.options}
-          />
-        );
-      })}
-      <Group justify="space-between">
-        <Button
-          variant="subtle"
-          onClick={() =>
-            openModal({
-              advancedOptions,
-              onSuccess(options) {
-                setAdvancedOptions(options);
-                innerProps.onSuccessfulEdit({
-                  ...innerProps.value,
-                  advancedOptions: options,
-                });
-              },
-            })
-          }
-        >
-          {t("item.edit.advancedOptions.label")}
-        </Button>
-        {!showAppTab && (
-          <Group justify="end" w={{ base: "100%", xs: "auto" }}>
-            <Button onClick={actions.closeModal} variant="subtle" color="gray">
-              {t("common.action.cancel")}
-            </Button>
-            <Button type="submit" loading={isSubmitting}>
-              {t("common.action.saveChanges")}
-            </Button>
-          </Group>
-        )}
-      </Group>
-    </Stack>
-  );
-
   return (
-    <form onSubmit={onFormSubmit}>
+    <form
+      onSubmit={form.onSubmit((values) => {
+        innerProps.onSuccessfulEdit({
+          ...values,
+          advancedOptions,
+        });
+        actions.closeModal();
+      })}
+    >
       <FormProvider form={form}>
-        {showAppTab ? (
-          <Stack>
-            <Tabs defaultValue="widget">
-              <Tabs.List grow>
-                <Tabs.Tab value="widget">{t("item.edit.tab.widget")}</Tabs.Tab>
-                <Tabs.Tab value="app">{t("item.edit.tab.app")}</Tabs.Tab>
-              </Tabs.List>
-              <Tabs.Panel value="widget" pt="md">
-                {widgetFormContent}
-              </Tabs.Panel>
-              <Tabs.Panel value="app" pt="md">
-                {appId && <EmbeddedAppEditForm appId={appId} handleRef={appEditRef} />}
-              </Tabs.Panel>
-            </Tabs>
-            <Group justify="end">
+        <Stack>
+          {innerProps.integrationSupport && (
+            <WidgetIntegrationSelect
+              label={t("item.edit.field.integrations.label")}
+              data={innerProps.integrationData}
+              {...form.getInputProps("integrationIds")}
+            />
+          )}
+          {Object.entries(options).map(([key, value]) => {
+            const Input = getInputForType(value.type);
+
+            if (
+              // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+              !Input ||
+              // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+              value.shouldHide?.(
+                form.values.options as never,
+                innerProps.integrationData
+                  .filter(({ id }) => form.values.integrationIds.includes(id))
+                  .map(({ kind }) => kind),
+              )
+            ) {
+              return null;
+            }
+
+            return (
+              <Input
+                key={key}
+                kind={innerProps.kind}
+                property={key}
+                options={value as never}
+                initialOptions={innerProps.value.options}
+              />
+            );
+          })}
+          <Group justify="space-between">
+            <Button
+              variant="subtle"
+              onClick={() =>
+                openModal({
+                  advancedOptions,
+                  onSuccess(options) {
+                    setAdvancedOptions(options);
+                    innerProps.onSuccessfulEdit({
+                      ...innerProps.value,
+                      advancedOptions: options,
+                    });
+                  },
+                })
+              }
+            >
+              {t("item.edit.advancedOptions.label")}
+            </Button>
+            <Group justify="end" w={{ base: "100%", xs: "auto" }}>
               <Button onClick={actions.closeModal} variant="subtle" color="gray">
                 {t("common.action.cancel")}
               </Button>
-              <Button type="submit" loading={isSubmitting}>
-                {t("common.action.saveChanges")}
-              </Button>
+              <Button type="submit">{t("common.action.saveChanges")}</Button>
             </Group>
-          </Stack>
-        ) : (
-          widgetFormContent
-        )}
+          </Group>
+        </Stack>
       </FormProvider>
     </form>
   );

packages/widgets/src/prefetch.ts

@@ -11,6 +11,8 @@ import prefetchForApps from "./app/prefetch";
 import prefetchForBookmarks from "./bookmarks/prefetch";
 import type { Prefetch, WidgetOptionsRecordOf } from "./definition";
 import type { inferOptionsFromCreator } from "./options";
+import prefetchRssFeedsAsync from "./rssFeed/prefetch";
+import prefetchWeatherAsync from "./weather/prefetch";
 
 const cachedGetServerSettingsAsync = cache(getServerSettingsAsync);
 
@@ -19,6 +21,8 @@ const prefetchCallbacks: Partial<{
 }> = {
   bookmarks: prefetchForBookmarks,
   app: prefetchForApps,
+  weather: prefetchWeatherAsync,
+  rssFeed: prefetchRssFeedsAsync,
 };
 
 export const prefetchForKindAsync = async <TKind extends WidgetKind>(

packages/widgets/src/rssFeed/prefetch.ts

@@ -0,0 +1,22 @@
+import { api, trpc } from "@homarr/api/server";
+import { createLogger } from "@homarr/core/infrastructure/logs";
+
+import type { Prefetch } from "../definition";
+
+const logger = createLogger({ module: "rssFeedWidgetPrefetch" });
+
+const prefetchRssFeedsAsync: Prefetch<"rssFeed"> = async (queryClient, items) => {
+  for (const item of items) {
+    const input = {
+      urls: item.options.feedUrls,
+      maximumAmountPosts: item.options.maximumAmountPosts,
+    };
+
+    const data = await api.widget.rssFeed.getFeeds(input);
+    queryClient.setQueryData(trpc.widget.rssFeed.getFeeds.queryKey(input), data);
+  }
+
+  logger.info("Successfully prefetched RSS feeds", { count: items.length });
+};
+
+export default prefetchRssFeedsAsync;

packages/widgets/src/weather/prefetch.ts

@@ -0,0 +1,29 @@
+import { api, trpc } from "@homarr/api/server";
+import { createLogger } from "@homarr/core/infrastructure/logs";
+
+import type { Prefetch } from "../definition";
+
+const logger = createLogger({ module: "weatherWidgetPrefetch" });
+
+const prefetchWeatherAsync: Prefetch<"weather"> = async (queryClient, items) => {
+  const locations = items.map((item) => ({
+    latitude: item.options.location.latitude,
+    longitude: item.options.location.longitude,
+  }));
+
+  const uniqueLocations = locations.filter(
+    (loc, idx, arr) =>
+      arr.findIndex((other) => other.latitude === loc.latitude && other.longitude === loc.longitude) === idx,
+  );
+
+  await Promise.all(
+    uniqueLocations.map(async (input) => {
+      const data = await api.widget.weather.atLocation(input);
+      queryClient.setQueryData(trpc.widget.weather.atLocation.queryKey(input), data);
+    }),
+  );
+
+  logger.info("Successfully prefetched weather data", { count: uniqueLocations.length });
+};
+
+export default prefetchWeatherAsync;

pnpm-lock.yaml

@@ -2144,9 +2144,6 @@ importers:
       '@homarr/modals-collection':
         specifier: workspace:^0.1.0
         version: link:../modals-collection
-      '@homarr/notifications':
-        specifier: workspace:^0.1.0
-        version: link:../notifications
       '@homarr/settings':
         specifier: workspace:^0.1.0
         version: link:../settings