Lesezeichen, Import/Export, Favoriten-Sortierung im Frontend, Favicon-Fix, sortierbare Spalten, Kategorie-Dropdown

packages/shared/src/index.ts

@@ -73,6 +73,44 @@ export interface PluginInfo {
   capabilities: string[];
 }
 
+/**
+ * Ein manuell angelegtes Lesezeichen – im Unterschied zu Diensten nicht an
+ * ein gescanntes Gerät gebunden. Erscheint zusammen mit Diensten in der
+ * Suche, wird aber als eigene Entität verwaltet (siehe Admin -> Lesezeichen).
+ */
+export interface Bookmark {
+  id: string;
+  url: string;
+  displayName: string;
+  hostname: string; // aus der URL abgeleitet, für konsistentes Ranking
+  description: string | null;
+  category: string | null;
+  icon: string | null;
+  favicon: string | null;
+  favorite: boolean;
+  alias: string[];
+  order: number;
+}
+
+/** Gemeinsame Form, die Service und Bookmark fürs Ranking erfüllen. */
+export interface Rankable {
+  displayName: string;
+  hostname: string;
+  alias: string[];
+  description: string | null;
+  favorite: boolean;
+  order: number;
+}
+
+/**
+ * Vereinheitlichte Suchtreffer-Form für die Trefferliste: Dienste und
+ * Lesezeichen zusammen, aber unterscheidbar über `kind` (siehe
+ * "getrennt von Diensten" bei Favoriten).
+ */
+export type SearchResult =
+  | (Service & { kind: "service" })
+  | (Bookmark & { kind: "bookmark" });
+
 /**
  * Ranking-Stufen für die Suche, gemäß Spezifikation:
  * 1. Displayname beginnt mit Suchtext
@@ -83,15 +121,17 @@ export interface PluginInfo {
  * 6. Beschreibung enthält Suchtext
  *
  * Niedrigere Werte sind relevanter. `null` bedeutet: kein Treffer.
+ * Funktioniert generisch für alles, was die Rankable-Form erfüllt
+ * (Service, Bookmark).
  */
-export function rankService(service: Service, query: string): number | null {
+export function rankService<T extends Rankable>(item: T, query: string): number | null {
   const q = query.trim().toLowerCase();
   if (q.length === 0) return null;
 
-  const displayName = service.displayName.toLowerCase();
-  const hostname = service.hostname.toLowerCase();
-  const description = (service.description ?? "").toLowerCase();
-  const alias = service.alias.map((a) => a.toLowerCase());
+  const displayName = item.displayName.toLowerCase();
+  const hostname = item.hostname.toLowerCase();
+  const description = (item.description ?? "").toLowerCase();
+  const alias = item.alias.map((a) => a.toLowerCase());
 
   if (displayName.startsWith(q)) return 1;
   if (alias.some((a) => a.startsWith(q))) return 2;
@@ -104,26 +144,27 @@ export function rankService(service: Service, query: string): number | null {
 }
 
 /**
- * Sortiert und filtert eine Liste von Diensten anhand des Suchtexts.
- * Favoriten werden bei gleichem Rang bevorzugt, danach die definierte Reihenfolge.
+ * Sortiert und filtert eine Liste (Dienste, Lesezeichen oder eine Mischung
+ * über einen gemeinsamen Union-Typ) anhand des Suchtexts. Favoriten werden
+ * bei gleichem Rang bevorzugt, danach die definierte Reihenfolge.
  */
-export function rankServices(services: Service[], query: string): Service[] {
+export function rankServices<T extends Rankable>(items: T[], query: string): T[] {
   const q = query.trim();
 
   if (q.length === 0) {
-    return [...services].sort((a, b) => {
+    return [...items].sort((a, b) => {
       if (a.favorite !== b.favorite) return a.favorite ? -1 : 1;
       return a.order - b.order;
     });
   }
 
-  return services
-    .map((service) => ({ service, rank: rankService(service, q) }))
-    .filter((entry): entry is { service: Service; rank: number } => entry.rank !== null)
+  return items
+    .map((item) => ({ item, rank: rankService(item, q) }))
+    .filter((entry): entry is { item: T; rank: number } => entry.rank !== null)
     .sort((a, b) => {
       if (a.rank !== b.rank) return a.rank - b.rank;
-      if (a.service.favorite !== b.service.favorite) return a.service.favorite ? -1 : 1;
-      return a.service.order - b.service.order;
+      if (a.item.favorite !== b.item.favorite) return a.item.favorite ? -1 : 1;
+      return a.item.order - b.item.order;
     })
-    .map((entry) => entry.service);
+    .map((entry) => entry.item);
 }

packages/shared/src/schemas.ts

@@ -78,3 +78,31 @@ export const CategoryReorderSchema = z
   )
   .min(1, "mindestens ein Eintrag erforderlich");
 export type CategoryReorderInput = z.infer<typeof CategoryReorderSchema>;
+
+export const BookmarkCreateSchema = z.object({
+  url: z.string().url("url muss eine gültige URL sein"),
+  // Optional: wird nicht angegeben, versucht das Backend automatisch den
+  // Seitentitel zu lesen (siehe apps/backend/src/routes/bookmarks.ts).
+  displayName: z.string().min(1).optional(),
+  description: z.string().optional(),
+  category: z.string().optional(),
+  icon: z.string().optional(),
+  favorite: z.boolean().optional(),
+  alias: z.array(z.string()).optional(),
+  order: z.number().optional(),
+});
+export type BookmarkCreateInput = z.infer<typeof BookmarkCreateSchema>;
+
+export const BookmarkUpdateSchema = BookmarkCreateSchema.partial();
+export type BookmarkUpdateInput = z.infer<typeof BookmarkUpdateSchema>;
+
+/** Für Drag & Drop: neue Reihenfolge mehrerer Lesezeichen auf einmal setzen. */
+export const BookmarkReorderSchema = z
+  .array(
+    z.object({
+      id: z.string().min(1),
+      order: z.number(),
+    })
+  )
+  .min(1, "mindestens ein Eintrag erforderlich");
+export type BookmarkReorderInput = z.infer<typeof BookmarkReorderSchema>;