feat(search): context-scoped search with filter chips and group order
Add a search scope (all/music/shows/movies) resolved from the entry route and adjustable via filter chips, threaded through the library store's search() into includeItemTypes. Results group by type in a user-configurable order, editable from settings. TRACES: UR-049 | DR-063, DR-064, DR-065; UR-050 | DR-066, DR-067
This commit is contained in:
@@ -0,0 +1,285 @@
|
||||
import { describe, it, expect } from "vitest";
|
||||
import {
|
||||
composeSearchGroups,
|
||||
DEFAULT_GROUP_ORDER,
|
||||
groupsForScope,
|
||||
moveGroup,
|
||||
normalizeGroupOrder,
|
||||
reorderGroups,
|
||||
resolveSearchScope,
|
||||
scopeItemTypes,
|
||||
type SearchGroupId,
|
||||
} from "./searchScope";
|
||||
|
||||
describe("resolveSearchScope", () => {
|
||||
it("scopes music routes to music", () => {
|
||||
expect(resolveSearchScope("/library/music")).toBe("music");
|
||||
expect(resolveSearchScope("/library/music/albums")).toBe("music");
|
||||
expect(resolveSearchScope("/library/music/artists")).toBe("music");
|
||||
expect(resolveSearchScope("/library/music/genres")).toBe("music");
|
||||
expect(resolveSearchScope("/library/music/playlists")).toBe("music");
|
||||
expect(resolveSearchScope("/library/music/tracks")).toBe("music");
|
||||
});
|
||||
|
||||
it("scopes movie routes to movies", () => {
|
||||
expect(resolveSearchScope("/library/movies")).toBe("movies");
|
||||
expect(resolveSearchScope("/library/movies/all")).toBe("movies");
|
||||
expect(resolveSearchScope("/library/movies/genres")).toBe("movies");
|
||||
});
|
||||
|
||||
it("scopes tv routes to tv", () => {
|
||||
expect(resolveSearchScope("/library/tv")).toBe("tv");
|
||||
expect(resolveSearchScope("/library/tv/shows")).toBe("tv");
|
||||
});
|
||||
|
||||
it("treats /library/shows as tv", () => {
|
||||
// The TV genre page lives under `shows`, not `tv`.
|
||||
expect(resolveSearchScope("/library/shows/genres")).toBe("tv");
|
||||
expect(resolveSearchScope("/library/shows")).toBe("tv");
|
||||
});
|
||||
|
||||
it("falls back to all for home, library root, search and unknown routes", () => {
|
||||
expect(resolveSearchScope("/")).toBe("all");
|
||||
expect(resolveSearchScope("/library")).toBe("all");
|
||||
expect(resolveSearchScope("/search")).toBe("all");
|
||||
expect(resolveSearchScope("/settings")).toBe("all");
|
||||
expect(resolveSearchScope("/downloads")).toBe("all");
|
||||
expect(resolveSearchScope("/library/abc123")).toBe("all");
|
||||
expect(resolveSearchScope("/nonsense/route")).toBe("all");
|
||||
});
|
||||
|
||||
it("tolerates trailing slashes, query strings and hashes", () => {
|
||||
expect(resolveSearchScope("/library/music/")).toBe("music");
|
||||
expect(resolveSearchScope("/library/tv?foo=1")).toBe("tv");
|
||||
expect(resolveSearchScope("/library/movies#top")).toBe("movies");
|
||||
expect(resolveSearchScope("")).toBe("all");
|
||||
});
|
||||
|
||||
it("does not match a prefix that is only a partial segment", () => {
|
||||
expect(resolveSearchScope("/library/musicvideos")).toBe("all");
|
||||
});
|
||||
});
|
||||
|
||||
describe("scopeItemTypes", () => {
|
||||
it("omits the key entirely for the all scope", () => {
|
||||
// `all` must send no includeItemTypes — an explicit union would silently
|
||||
// drop types nobody enumerated (Person, folders).
|
||||
expect(scopeItemTypes("all")).toBeUndefined();
|
||||
});
|
||||
|
||||
it("maps each narrow scope to its item types", () => {
|
||||
expect(scopeItemTypes("music")).toEqual(["MusicAlbum", "MusicArtist", "Audio", "Playlist"]);
|
||||
expect(scopeItemTypes("movies")).toEqual(["Movie"]);
|
||||
expect(scopeItemTypes("tv")).toEqual(["Series", "Episode"]);
|
||||
});
|
||||
|
||||
it("returns a fresh array callers cannot mutate into the table", () => {
|
||||
const first = scopeItemTypes("movies")!;
|
||||
first.push("Series");
|
||||
expect(scopeItemTypes("movies")).toEqual(["Movie"]);
|
||||
});
|
||||
});
|
||||
|
||||
describe("normalizeGroupOrder", () => {
|
||||
it("returns the default for missing or non-array input", () => {
|
||||
expect(normalizeGroupOrder(null)).toEqual([...DEFAULT_GROUP_ORDER]);
|
||||
expect(normalizeGroupOrder(undefined)).toEqual([...DEFAULT_GROUP_ORDER]);
|
||||
expect(normalizeGroupOrder("nonsense")).toEqual([...DEFAULT_GROUP_ORDER]);
|
||||
expect(normalizeGroupOrder({})).toEqual([...DEFAULT_GROUP_ORDER]);
|
||||
});
|
||||
|
||||
it("drops ids that no longer exist", () => {
|
||||
expect(normalizeGroupOrder(["movies", "podcasts", "songs"])).toEqual([
|
||||
"movies",
|
||||
"songs",
|
||||
"albums",
|
||||
"artists",
|
||||
"tvShows",
|
||||
]);
|
||||
});
|
||||
|
||||
it("appends groups a stored order does not mention", () => {
|
||||
// A user upgrading from a build with fewer groups must not lose the new ones.
|
||||
expect(normalizeGroupOrder(["movies", "songs"])).toEqual([
|
||||
"movies",
|
||||
"songs",
|
||||
"albums",
|
||||
"artists",
|
||||
"tvShows",
|
||||
]);
|
||||
});
|
||||
|
||||
it("de-duplicates repeated ids", () => {
|
||||
expect(normalizeGroupOrder(["songs", "songs", "movies"])).toEqual([
|
||||
"songs",
|
||||
"movies",
|
||||
"albums",
|
||||
"artists",
|
||||
"tvShows",
|
||||
]);
|
||||
});
|
||||
|
||||
it("preserves a complete valid order unchanged", () => {
|
||||
const order: SearchGroupId[] = ["tvShows", "movies", "artists", "albums", "songs"];
|
||||
expect(normalizeGroupOrder(order)).toEqual(order);
|
||||
});
|
||||
});
|
||||
|
||||
describe("groupsForScope", () => {
|
||||
it("returns every group in saved order for the all scope", () => {
|
||||
expect(groupsForScope("all", ["movies", "songs", "tvShows", "albums", "artists"])).toEqual([
|
||||
"movies",
|
||||
"songs",
|
||||
"tvShows",
|
||||
"albums",
|
||||
"artists",
|
||||
]);
|
||||
});
|
||||
|
||||
it("keeps only in-scope groups, in saved order", () => {
|
||||
const order: SearchGroupId[] = ["artists", "movies", "albums", "tvShows", "songs"];
|
||||
expect(groupsForScope("music", order)).toEqual(["artists", "albums", "songs"]);
|
||||
expect(groupsForScope("movies", order)).toEqual(["movies"]);
|
||||
expect(groupsForScope("tv", order)).toEqual(["tvShows"]);
|
||||
});
|
||||
});
|
||||
|
||||
describe("composeSearchGroups", () => {
|
||||
const results = [
|
||||
{ id: "1", type: "Audio" },
|
||||
{ id: "2", type: "MusicAlbum" },
|
||||
{ id: "3", type: "Movie" },
|
||||
{ id: "4", type: "Series" },
|
||||
{ id: "5", type: "Episode" },
|
||||
{ id: "6", type: "Person" },
|
||||
];
|
||||
|
||||
it("renders groups in the configured order", () => {
|
||||
const groups = composeSearchGroups(results, "all", [
|
||||
"tvShows",
|
||||
"movies",
|
||||
"songs",
|
||||
"albums",
|
||||
"artists",
|
||||
]);
|
||||
expect(groups.map((g) => g.id)).toEqual(["tvShows", "movies", "songs", "albums"]);
|
||||
});
|
||||
|
||||
it("omits empty groups", () => {
|
||||
// No artists in the fixture, so the artists group never renders.
|
||||
const groups = composeSearchGroups(results, "all", DEFAULT_GROUP_ORDER);
|
||||
expect(groups.map((g) => g.id)).not.toContain("artists");
|
||||
});
|
||||
|
||||
it("drops out-of-scope groups", () => {
|
||||
expect(composeSearchGroups(results, "music", DEFAULT_GROUP_ORDER).map((g) => g.id)).toEqual([
|
||||
"songs",
|
||||
"albums",
|
||||
]);
|
||||
expect(composeSearchGroups(results, "tv", DEFAULT_GROUP_ORDER).map((g) => g.id)).toEqual([
|
||||
"tvShows",
|
||||
]);
|
||||
});
|
||||
|
||||
it("groups series and episodes together under tvShows", () => {
|
||||
const groups = composeSearchGroups(results, "tv", DEFAULT_GROUP_ORDER);
|
||||
expect(groups[0].items.map((i) => i.id)).toEqual(["4", "5"]);
|
||||
});
|
||||
|
||||
it("ignores item types that belong to no group", () => {
|
||||
const all = composeSearchGroups(results, "all", DEFAULT_GROUP_ORDER);
|
||||
expect(all.flatMap((g) => g.items).map((i) => i.id)).not.toContain("6");
|
||||
});
|
||||
|
||||
it("narrowing then widening restores the full arrangement", () => {
|
||||
// Scope is a filter over the saved order, never a rewrite of it.
|
||||
const order: SearchGroupId[] = ["tvShows", "songs", "movies", "albums", "artists"];
|
||||
const wide = composeSearchGroups(results, "all", order).map((g) => g.id);
|
||||
composeSearchGroups(results, "music", order);
|
||||
expect(composeSearchGroups(results, "all", order).map((g) => g.id)).toEqual(wide);
|
||||
expect(wide).toEqual(["tvShows", "songs", "movies", "albums"]);
|
||||
});
|
||||
|
||||
it("survives a stored order containing an unknown id", () => {
|
||||
const groups = composeSearchGroups(results, "all", [
|
||||
"podcasts",
|
||||
"movies",
|
||||
] as unknown as SearchGroupId[]);
|
||||
expect(groups.map((g) => g.id)).toEqual(["movies", "songs", "albums", "tvShows"]);
|
||||
});
|
||||
|
||||
it("handles items with a missing type", () => {
|
||||
const groups = composeSearchGroups(
|
||||
[{ id: "x", type: null }, { id: "y" }] as { id: string; type?: string | null }[],
|
||||
"all",
|
||||
DEFAULT_GROUP_ORDER
|
||||
);
|
||||
expect(groups).toEqual([]);
|
||||
});
|
||||
});
|
||||
|
||||
describe("moveGroup", () => {
|
||||
const order: SearchGroupId[] = ["songs", "albums", "artists", "movies", "tvShows"];
|
||||
|
||||
it("moves a group up", () => {
|
||||
expect(moveGroup(order, "artists", -1)).toEqual([
|
||||
"songs",
|
||||
"artists",
|
||||
"albums",
|
||||
"movies",
|
||||
"tvShows",
|
||||
]);
|
||||
});
|
||||
|
||||
it("moves a group down", () => {
|
||||
expect(moveGroup(order, "songs", 1)).toEqual([
|
||||
"albums",
|
||||
"songs",
|
||||
"artists",
|
||||
"movies",
|
||||
"tvShows",
|
||||
]);
|
||||
});
|
||||
|
||||
it("is a no-op at the boundaries", () => {
|
||||
expect(moveGroup(order, "songs", -1)).toEqual(order);
|
||||
expect(moveGroup(order, "tvShows", 1)).toEqual(order);
|
||||
});
|
||||
|
||||
it("is a no-op for an unknown id", () => {
|
||||
expect(moveGroup(order, "podcasts" as SearchGroupId, 1)).toEqual(order);
|
||||
});
|
||||
|
||||
it("does not mutate the input", () => {
|
||||
const input = [...order];
|
||||
moveGroup(input, "songs", 1);
|
||||
expect(input).toEqual(order);
|
||||
});
|
||||
});
|
||||
|
||||
describe("reorderGroups", () => {
|
||||
const order: SearchGroupId[] = ["songs", "albums", "artists", "movies", "tvShows"];
|
||||
|
||||
it("moves an item from one index to another", () => {
|
||||
expect(reorderGroups(order, 0, 4)).toEqual([
|
||||
"albums",
|
||||
"artists",
|
||||
"movies",
|
||||
"tvShows",
|
||||
"songs",
|
||||
]);
|
||||
expect(reorderGroups(order, 4, 0)).toEqual([
|
||||
"tvShows",
|
||||
"songs",
|
||||
"albums",
|
||||
"artists",
|
||||
"movies",
|
||||
]);
|
||||
});
|
||||
|
||||
it("is a no-op for equal or out-of-range indices", () => {
|
||||
expect(reorderGroups(order, 2, 2)).toEqual(order);
|
||||
expect(reorderGroups(order, -1, 2)).toEqual(order);
|
||||
expect(reorderGroups(order, 0, 9)).toEqual(order);
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,205 @@
|
||||
// Search scoping and result-group ordering.
|
||||
//
|
||||
// Two independent axes govern how search results are presented:
|
||||
// - *scope* narrows which item types are requested from the repository,
|
||||
// - *group order* decides the sequence the surviving groups render in.
|
||||
// Neither one rewrites the other: narrowing to Music and widening back to All
|
||||
// restores the user's saved arrangement untouched.
|
||||
//
|
||||
// TRACES: UR-049, UR-050 | DR-063, DR-066, DR-067
|
||||
|
||||
export type SearchScope = "all" | "music" | "movies" | "tv";
|
||||
|
||||
export const SEARCH_SCOPES: readonly SearchScope[] = ["all", "music", "movies", "tv"];
|
||||
|
||||
export const SCOPE_LABELS: Record<SearchScope, string> = {
|
||||
all: "All",
|
||||
music: "Music",
|
||||
movies: "Movies",
|
||||
tv: "TV",
|
||||
};
|
||||
|
||||
/**
|
||||
* Jellyfin item types requested for each scope.
|
||||
*
|
||||
* `all` is deliberately absent: sending no `includeItemTypes` is *not* the same
|
||||
* as sending the union of the lists below — types nobody enumerated here
|
||||
* (Person, folders, …) would be filtered out by an explicit list.
|
||||
*/
|
||||
const SCOPE_ITEM_TYPES: Record<Exclude<SearchScope, "all">, string[]> = {
|
||||
music: ["MusicAlbum", "MusicArtist", "Audio", "Playlist"],
|
||||
movies: ["Movie"],
|
||||
tv: ["Series", "Episode"],
|
||||
};
|
||||
|
||||
/**
|
||||
* Item types to send with a scoped search, or `undefined` for the `all` scope
|
||||
* so the caller omits the key entirely.
|
||||
*
|
||||
* TRACES: UR-049 | DR-063
|
||||
*/
|
||||
export function scopeItemTypes(scope: SearchScope): string[] | undefined {
|
||||
if (scope === "all") return undefined;
|
||||
return [...SCOPE_ITEM_TYPES[scope]];
|
||||
}
|
||||
|
||||
/**
|
||||
* Resolve the scope a search started from a given route should default to.
|
||||
* Pure — takes a pathname, touches no DOM, so it unit-tests directly.
|
||||
*
|
||||
* TRACES: UR-049 | DR-063
|
||||
*/
|
||||
export function resolveSearchScope(pathname: string): SearchScope {
|
||||
// Tolerate query strings, hashes and trailing slashes.
|
||||
const path = pathname.split(/[?#]/)[0].replace(/\/+$/, "") || "/";
|
||||
|
||||
if (path === "/library/music" || path.startsWith("/library/music/")) return "music";
|
||||
if (path === "/library/movies" || path.startsWith("/library/movies/")) return "movies";
|
||||
if (path === "/library/tv" || path.startsWith("/library/tv/")) return "tv";
|
||||
// `/library/shows/genres` is the TV genre route despite the differing segment.
|
||||
if (path === "/library/shows" || path.startsWith("/library/shows/")) return "tv";
|
||||
|
||||
return "all";
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Result groups
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
export type SearchGroupId = "songs" | "albums" | "artists" | "movies" | "tvShows";
|
||||
|
||||
/** Shipped default order, per the spec. */
|
||||
export const DEFAULT_GROUP_ORDER: readonly SearchGroupId[] = [
|
||||
"songs",
|
||||
"albums",
|
||||
"artists",
|
||||
"movies",
|
||||
"tvShows",
|
||||
];
|
||||
|
||||
export const GROUP_LABELS: Record<SearchGroupId, string> = {
|
||||
songs: "Songs",
|
||||
albums: "Albums",
|
||||
artists: "Artists",
|
||||
movies: "Movies",
|
||||
tvShows: "TV Shows",
|
||||
};
|
||||
|
||||
/** Which scopes each group belongs to (`all` always includes everything). */
|
||||
const GROUP_SCOPE: Record<SearchGroupId, Exclude<SearchScope, "all">> = {
|
||||
songs: "music",
|
||||
albums: "music",
|
||||
artists: "music",
|
||||
movies: "movies",
|
||||
tvShows: "tv",
|
||||
};
|
||||
|
||||
/** Item types that fall into each group. */
|
||||
const GROUP_ITEM_TYPES: Record<SearchGroupId, string[]> = {
|
||||
songs: ["Audio"],
|
||||
albums: ["MusicAlbum"],
|
||||
artists: ["MusicArtist"],
|
||||
movies: ["Movie"],
|
||||
tvShows: ["Series", "Episode"],
|
||||
};
|
||||
|
||||
export function groupItemTypes(group: SearchGroupId): string[] {
|
||||
return [...GROUP_ITEM_TYPES[group]];
|
||||
}
|
||||
|
||||
/**
|
||||
* Normalise a stored order into a usable one.
|
||||
*
|
||||
* The stored array is a *hint*, not a contract: ids that no longer exist are
|
||||
* dropped, and groups it never mentions (a user upgrading from a build with
|
||||
* fewer groups) are appended in default order rather than lost.
|
||||
*
|
||||
* TRACES: UR-050 | DR-066
|
||||
*/
|
||||
export function normalizeGroupOrder(stored: unknown): SearchGroupId[] {
|
||||
const known = new Set<string>(DEFAULT_GROUP_ORDER);
|
||||
const seen = new Set<SearchGroupId>();
|
||||
const order: SearchGroupId[] = [];
|
||||
|
||||
if (Array.isArray(stored)) {
|
||||
for (const id of stored) {
|
||||
if (typeof id !== "string" || !known.has(id)) continue;
|
||||
const groupId = id as SearchGroupId;
|
||||
if (seen.has(groupId)) continue;
|
||||
seen.add(groupId);
|
||||
order.push(groupId);
|
||||
}
|
||||
}
|
||||
|
||||
for (const id of DEFAULT_GROUP_ORDER) {
|
||||
if (!seen.has(id)) order.push(id);
|
||||
}
|
||||
|
||||
return order;
|
||||
}
|
||||
|
||||
/** Groups visible under a scope, in the user's configured order. */
|
||||
export function groupsForScope(
|
||||
scope: SearchScope,
|
||||
order: readonly SearchGroupId[] = DEFAULT_GROUP_ORDER
|
||||
): SearchGroupId[] {
|
||||
return normalizeGroupOrder(order as SearchGroupId[]).filter(
|
||||
(id) => scope === "all" || GROUP_SCOPE[id] === scope
|
||||
);
|
||||
}
|
||||
|
||||
export interface SearchGroup<T> {
|
||||
id: SearchGroupId;
|
||||
label: string;
|
||||
items: T[];
|
||||
}
|
||||
|
||||
/**
|
||||
* Compose scope, saved order and the results into the sections to render:
|
||||
* drop out-of-scope groups, sort by the saved order, omit empty groups.
|
||||
*
|
||||
* TRACES: UR-050 | DR-067
|
||||
*/
|
||||
export function composeSearchGroups<T extends { type?: string | null }>(
|
||||
results: readonly T[],
|
||||
scope: SearchScope,
|
||||
order: readonly SearchGroupId[] = DEFAULT_GROUP_ORDER
|
||||
): SearchGroup<T>[] {
|
||||
return groupsForScope(scope, order)
|
||||
.map((id) => {
|
||||
const types = GROUP_ITEM_TYPES[id];
|
||||
return {
|
||||
id,
|
||||
label: GROUP_LABELS[id],
|
||||
items: results.filter((item) => item.type != null && types.includes(item.type)),
|
||||
};
|
||||
})
|
||||
.filter((group) => group.items.length > 0);
|
||||
}
|
||||
|
||||
/** Move a group one slot up (-1) or down (+1); out-of-range moves are no-ops. */
|
||||
export function moveGroup(
|
||||
order: readonly SearchGroupId[],
|
||||
id: SearchGroupId,
|
||||
delta: number
|
||||
): SearchGroupId[] {
|
||||
const next = [...order];
|
||||
const from = next.indexOf(id);
|
||||
if (from === -1) return next;
|
||||
const to = from + delta;
|
||||
if (to < 0 || to >= next.length) return next;
|
||||
next.splice(to, 0, ...next.splice(from, 1));
|
||||
return next;
|
||||
}
|
||||
|
||||
/** Move a group from one index to another (drag-and-drop drop handler). */
|
||||
export function reorderGroups(
|
||||
order: readonly SearchGroupId[],
|
||||
from: number,
|
||||
to: number
|
||||
): SearchGroupId[] {
|
||||
const next = [...order];
|
||||
if (from < 0 || from >= next.length || to < 0 || to >= next.length || from === to) return next;
|
||||
next.splice(to, 0, ...next.splice(from, 1));
|
||||
return next;
|
||||
}
|
||||
Reference in New Issue
Block a user