mirror of
https://seed.radicle.dev/rad:z4V1sjrXqjvFdnCUbxPFqd5p4DtH5.git
synced 2026-11-21 14:20:42 +08:00
desktop: Add new commits to the commits list
When the branch moves on, its new commits are added at the top of the list, without moving the rows in view, instead of the list going stale until the next visit. Rewritten history offers to reload the list.
This commit is contained in:
@@ -289,7 +289,10 @@
|
||||
{:else if $activeRouteStore.resource === "repo.home"}
|
||||
<RepoHome {...$activeRouteStore.params} />
|
||||
{:else if $activeRouteStore.resource === "repo.commits"}
|
||||
<RepoCommits {...$activeRouteStore.params} />
|
||||
<!-- A reload from a newer head starts the list over. -->
|
||||
{#key `${$activeRouteStore.params.peer}:${$activeRouteStore.params.revision}:${$activeRouteStore.params.oid}`}
|
||||
<RepoCommits {...$activeRouteStore.params} />
|
||||
{/key}
|
||||
{:else if $activeRouteStore.resource === "repo.commit"}
|
||||
<RepoCommit {...$activeRouteStore.params} />
|
||||
{:else if $activeRouteStore.resource === "repo.identity"}
|
||||
|
||||
@@ -28,6 +28,9 @@
|
||||
autoStartMargin?: boolean;
|
||||
// Distance from the bottom (in pixels) at which to request the next page.
|
||||
prefetchPx?: number;
|
||||
// Keep the rows in view where they are when rows are added before them,
|
||||
// for a list that only ever grows at the top or the bottom.
|
||||
keepRowsOnPrepend?: boolean;
|
||||
// Restore a previously-captured scroll position (used on history nav).
|
||||
initialCache?: ListCacheSnapshot;
|
||||
initialScrollOffset?: number;
|
||||
@@ -60,6 +63,7 @@
|
||||
startMargin = undefined,
|
||||
autoStartMargin = false,
|
||||
prefetchPx = 800,
|
||||
keepRowsOnPrepend = false,
|
||||
initialCache = undefined,
|
||||
initialScrollOffset = undefined,
|
||||
onRestored = undefined,
|
||||
@@ -75,6 +79,39 @@
|
||||
let handle = $state<VirtualizerHandle | undefined>(undefined);
|
||||
let restored = false;
|
||||
|
||||
// With `keepRowsOnPrepend`, rows added before the ones in view, such as new
|
||||
// commits at the top, keep the rows in view where they are, so that nothing
|
||||
// moves under the reader. Virtua keeps the position from the end while
|
||||
// `shift` is set, which only holds when the end stays the same, so not for
|
||||
// pages loaded at the end. At the very top, new rows show instead.
|
||||
let shift = $state(false);
|
||||
let lastKey: string | number | undefined;
|
||||
let lastLength = 0;
|
||||
$effect.pre(() => {
|
||||
const last = items.length > 0 ? keyOf(items.length - 1) : undefined;
|
||||
shift =
|
||||
keepRowsOnPrepend &&
|
||||
lastKey !== undefined &&
|
||||
last === lastKey &&
|
||||
items.length > lastLength &&
|
||||
(viewport?.scrollTop ?? 0) > 0;
|
||||
lastKey = last;
|
||||
lastLength = items.length;
|
||||
});
|
||||
// Only for the update that added the rows: virtua also applies it to rows
|
||||
// that resize later.
|
||||
$effect(() => {
|
||||
if (!shift) return;
|
||||
const id = requestAnimationFrame(() => {
|
||||
shift = false;
|
||||
});
|
||||
return () => cancelAnimationFrame(id);
|
||||
});
|
||||
|
||||
function keyOf(index: number): string | number {
|
||||
return getKey ? getKey(items[index], index) : index;
|
||||
}
|
||||
|
||||
// A zero-height marker placed right before the virtualizer; its position
|
||||
// tells us how far down the list starts inside the scroll viewport.
|
||||
let anchorEl = $state<HTMLElement | undefined>(undefined);
|
||||
@@ -211,6 +248,7 @@
|
||||
itemSize={estimatedItemSize}
|
||||
{bufferSize}
|
||||
startMargin={effectiveStartMargin}
|
||||
{shift}
|
||||
cache={initialCache}
|
||||
onscroll={onScroll}
|
||||
onscrollend={reportState}>
|
||||
|
||||
@@ -0,0 +1,52 @@
|
||||
import type { Commit } from "@bindings/repo/Commit";
|
||||
|
||||
import { keys } from "@radicle-gui/core/keys";
|
||||
import {
|
||||
createQuery,
|
||||
invalidatedSinceLoading,
|
||||
} from "@radicle-gui/ui/lib/query.svelte";
|
||||
|
||||
import { invoke } from "@app/lib/invoke";
|
||||
import { queryClient } from "@app/lib/query";
|
||||
|
||||
interface ResolvedRevision {
|
||||
rid: string;
|
||||
peer: string | undefined;
|
||||
revision: string | undefined;
|
||||
// The commit the route loader resolved the revision to.
|
||||
oid: string;
|
||||
}
|
||||
|
||||
// The commit a revision resolves to now. A branch, or the default branch
|
||||
// without a revision, can move on while the user reads, so a view keeps
|
||||
// showing the loaded commit and offers the newer one. Create it during
|
||||
// component initialisation; the route loader marks `keys.head` as loading first.
|
||||
export function latestHead(revision: () => ResolvedRevision): {
|
||||
readonly current: string | undefined;
|
||||
} {
|
||||
const headKey = $derived(
|
||||
keys.head(revision().rid, revision().peer, revision().revision),
|
||||
);
|
||||
// The loader has just resolved the revision, so that is the latest commit.
|
||||
// A ref update during the load may have moved it since, so then the head is
|
||||
// checked again at mount, and a push during the load still shows as newer.
|
||||
$effect.pre(() => {
|
||||
queryClient.setQueryData(headKey, revision().oid);
|
||||
if (invalidatedSinceLoading(queryClient, headKey)) {
|
||||
void queryClient.invalidateQueries({ queryKey: headKey, exact: true });
|
||||
}
|
||||
});
|
||||
const head = createQuery<string>(queryClient, () => {
|
||||
const { rid, peer, revision: rev } = revision();
|
||||
return {
|
||||
queryKey: headKey,
|
||||
queryFn: async () =>
|
||||
(await invoke<Commit>("repo_commit", { rid, peer, revision: rev })).id,
|
||||
};
|
||||
});
|
||||
return {
|
||||
get current() {
|
||||
return head.current.data;
|
||||
},
|
||||
};
|
||||
}
|
||||
@@ -0,0 +1,37 @@
|
||||
import type { PaginatedQuery } from "@bindings/cob/PaginatedQuery";
|
||||
|
||||
interface CommitLike {
|
||||
id: string;
|
||||
parents: string[];
|
||||
}
|
||||
|
||||
export type NewerCommits<T> =
|
||||
| { type: "added"; commits: T[]; merge: boolean }
|
||||
// `from` isn't among the newer commit's ancestors, so history was rewritten.
|
||||
| { type: "rewritten" };
|
||||
|
||||
// The commits a branch gained since `from`, newest first, fetched a page at a
|
||||
// time from the new head and up to `limit` of them.
|
||||
export async function newerCommits<T extends CommitLike>(
|
||||
fetchPage: (skip: number, take: number) => Promise<PaginatedQuery<T[]>>,
|
||||
from: string,
|
||||
limit: number,
|
||||
pageSize: number,
|
||||
): Promise<NewerCommits<T>> {
|
||||
const added: T[] = [];
|
||||
for (let skip = 0; skip < limit; skip += pageSize) {
|
||||
const page = await fetchPage(skip, pageSize);
|
||||
const at = page.content.findIndex(commit => commit.id === from);
|
||||
if (at >= 0) {
|
||||
added.push(...page.content.slice(0, at));
|
||||
return {
|
||||
type: "added",
|
||||
commits: added,
|
||||
merge: added.some(commit => commit.parents.length > 1),
|
||||
};
|
||||
}
|
||||
added.push(...page.content);
|
||||
if (!page.more) break;
|
||||
}
|
||||
return { type: "rewritten" };
|
||||
}
|
||||
@@ -63,6 +63,8 @@ export function createPaginatedList<T>(opts: PaginatedListOptions<T>) {
|
||||
let activeKey = opts.key();
|
||||
|
||||
const loader = mutexExecutor.create();
|
||||
// Rows added at the top so far; see `prepend`.
|
||||
let prepended = 0;
|
||||
const abort = async (): Promise<undefined> => undefined;
|
||||
|
||||
// Parent reuses the view across filter changes; a key change resets the
|
||||
@@ -98,6 +100,8 @@ export function createPaginatedList<T>(opts: PaginatedListOptions<T>) {
|
||||
}
|
||||
}
|
||||
let superseded = false;
|
||||
let again = false;
|
||||
const prependedBefore = prepended;
|
||||
try {
|
||||
const page = await loader.run(async () =>
|
||||
opts.fetchPage(all ? 0 : cursor, all ? undefined : opts.pageSize),
|
||||
@@ -112,6 +116,12 @@ export function createPaginatedList<T>(opts: PaginatedListOptions<T>) {
|
||||
return;
|
||||
}
|
||||
|
||||
// Rows added at the top meanwhile would be lost by replacing the list
|
||||
// with a page fetched from before them, so fetch again.
|
||||
if (all && prepended !== prependedBefore) {
|
||||
again = true;
|
||||
return;
|
||||
}
|
||||
more = page.more;
|
||||
if (all) {
|
||||
items = page.content;
|
||||
@@ -135,6 +145,8 @@ export function createPaginatedList<T>(opts: PaginatedListOptions<T>) {
|
||||
if (!superseded) {
|
||||
loadingMore = false;
|
||||
}
|
||||
// In `finally`, since the check above returns early.
|
||||
if (again) await loadMore(true);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -148,12 +160,19 @@ export function createPaginatedList<T>(opts: PaginatedListOptions<T>) {
|
||||
async function revalidate(window: number = opts.pageSize): Promise<void> {
|
||||
loadingMore = true;
|
||||
let superseded = false;
|
||||
let again = false;
|
||||
const prependedBefore = prepended;
|
||||
try {
|
||||
const page = await loader.run(async () => opts.fetchPage(0, window));
|
||||
if (page === undefined) {
|
||||
superseded = true;
|
||||
return;
|
||||
}
|
||||
// As in `loadMore`: fetch again, wide enough for the rows added.
|
||||
if (prepended !== prependedBefore) {
|
||||
again = true;
|
||||
return;
|
||||
}
|
||||
items = page.content;
|
||||
cursor = page.content.length;
|
||||
more = page.more;
|
||||
@@ -166,6 +185,8 @@ export function createPaginatedList<T>(opts: PaginatedListOptions<T>) {
|
||||
if (!superseded) {
|
||||
loadingMore = false;
|
||||
}
|
||||
// In `finally`, since the check above returns early.
|
||||
if (again) await revalidate(window + prepended - prependedBefore);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -217,6 +238,19 @@ export function createPaginatedList<T>(opts: PaginatedListOptions<T>) {
|
||||
}
|
||||
}
|
||||
|
||||
// Add rows that now come before the first one, such as commits on a branch
|
||||
// that moved on. They count towards the offset, since `fetchPage` now pages
|
||||
// from before them; a page appended while it was in flight still lands
|
||||
// right, as it was asked for at the offset before them, and a page that
|
||||
// replaces the list is fetched again.
|
||||
function prepend(newItems: T[]): void {
|
||||
// eslint-disable-next-line svelte/prefer-svelte-reactivity -- transient local set, never rendered
|
||||
const seen = new Set(items.map(opts.id));
|
||||
items = [...newItems.filter(i => !seen.has(opts.id(i))), ...items];
|
||||
cursor += newItems.length;
|
||||
prepended += newItems.length;
|
||||
}
|
||||
|
||||
if (staleWindow !== undefined) {
|
||||
void revalidate(staleWindow);
|
||||
}
|
||||
@@ -271,6 +305,7 @@ export function createPaginatedList<T>(opts: PaginatedListOptions<T>) {
|
||||
loadMore,
|
||||
revalidate,
|
||||
refresh,
|
||||
prepend,
|
||||
persistScroll,
|
||||
};
|
||||
}
|
||||
|
||||
@@ -9,13 +9,17 @@
|
||||
import { commitRowsOf, groupCommitsByDay } from "@app/lib/commitGroups";
|
||||
import { debounced } from "@app/lib/debounced.svelte";
|
||||
import { invoke } from "@app/lib/invoke";
|
||||
import { latestHead } from "@app/lib/latestHead.svelte";
|
||||
import { newerCommits } from "@app/lib/newerCommits";
|
||||
import { createPaginatedList } from "@app/lib/paginatedList.svelte";
|
||||
import * as router from "@app/lib/router";
|
||||
import type { SidebarData } from "@app/lib/router/definitions";
|
||||
import { modifierKey } from "@app/lib/utils";
|
||||
|
||||
import Button from "@app/components/Button.svelte";
|
||||
import CobCommitTeaser from "@app/components/CobCommitTeaser.svelte";
|
||||
import FuzzySearch from "@app/components/FuzzySearch.svelte";
|
||||
import Icon from "@app/components/Icon.svelte";
|
||||
import RepoHeader from "@app/components/RepoHeader.svelte";
|
||||
import ScrollArea from "@app/components/ScrollArea.svelte";
|
||||
import SourceHeader from "@app/components/SourceHeader.svelte";
|
||||
@@ -52,13 +56,21 @@
|
||||
const debouncedSearch = debounced(() => searchInput, 150);
|
||||
let showSearch = $state(false);
|
||||
|
||||
// The commit the list pages from: the loaded one, then each newer one the
|
||||
// branch moves on to, whose commits are added at the top. A reload from a
|
||||
// newer head mounts the page anew, so the loaded props never change here.
|
||||
// svelte-ignore state_referenced_locally
|
||||
let listHead = $state(oid);
|
||||
// svelte-ignore state_referenced_locally
|
||||
let headCommit = $state(commit);
|
||||
|
||||
const list = createPaginatedList<Commit>({
|
||||
key: () => listKey(),
|
||||
page: () => commits,
|
||||
fetchPage: (skip, take) =>
|
||||
invoke<PaginatedQuery<Commit[]>>("list_repo_commits", {
|
||||
rid: repo.rid,
|
||||
head: oid,
|
||||
head: listHead,
|
||||
skip,
|
||||
take,
|
||||
}),
|
||||
@@ -67,6 +79,72 @@
|
||||
skipPersist: () => searchInput !== "",
|
||||
});
|
||||
|
||||
const latest = latestHead(() => ({ rid: repo.rid, peer, revision, oid }));
|
||||
// A newer head that doesn't descend from the list's, such as after a force
|
||||
// push, can't be added at the top; the list offers to start over instead.
|
||||
let rewritten: string | undefined = $state();
|
||||
// A head whose commits couldn't be fetched, tried again once it moves on.
|
||||
let failed: string | undefined = $state();
|
||||
let catchingUp = $state(false);
|
||||
|
||||
// Catches up with each head in turn, also one that moved on while the last
|
||||
// catch-up ran.
|
||||
$effect(() => {
|
||||
const newer = latest.current;
|
||||
if (
|
||||
newer === undefined ||
|
||||
catchingUp ||
|
||||
newer === listHead ||
|
||||
newer === rewritten ||
|
||||
newer === failed
|
||||
) {
|
||||
return;
|
||||
}
|
||||
catchingUp = true;
|
||||
void addNewer(newer)
|
||||
.catch(error => {
|
||||
failed = newer;
|
||||
console.error("Adding newer commits failed", error);
|
||||
})
|
||||
.finally(() => {
|
||||
catchingUp = false;
|
||||
});
|
||||
});
|
||||
|
||||
// How far back to look for the list's head before taking the history as
|
||||
// rewritten.
|
||||
const CATCH_UP_LIMIT = 1_000;
|
||||
const CATCH_UP_PAGE = 50;
|
||||
|
||||
async function addNewer(newer: string): Promise<void> {
|
||||
const result = await newerCommits(
|
||||
(skip, take) =>
|
||||
invoke<PaginatedQuery<Commit[]>>("list_repo_commits", {
|
||||
rid: repo.rid,
|
||||
head: newer,
|
||||
skip,
|
||||
take,
|
||||
}),
|
||||
listHead,
|
||||
CATCH_UP_LIMIT,
|
||||
CATCH_UP_PAGE,
|
||||
);
|
||||
if (result.type === "rewritten") {
|
||||
rewritten = newer;
|
||||
return;
|
||||
}
|
||||
listHead = newer;
|
||||
headCommit = result.commits[0] ?? headCommit;
|
||||
rewritten = undefined;
|
||||
if (result.merge) {
|
||||
// A merge brings in commits older than the list's head, which belong
|
||||
// further down, so the shown rows are fetched again instead.
|
||||
await list.revalidate(list.items.length + result.commits.length);
|
||||
} else {
|
||||
list.prepend(result.commits);
|
||||
}
|
||||
}
|
||||
|
||||
const searchableCommits = $derived(
|
||||
list.items.map(c => ({
|
||||
commit: c,
|
||||
@@ -130,10 +208,22 @@
|
||||
{repo}
|
||||
{peer}
|
||||
{revision}
|
||||
{oid}
|
||||
{commit}
|
||||
oid={listHead}
|
||||
commit={headCommit}
|
||||
{baseRoute}
|
||||
active="commits">
|
||||
{#snippet notice()}
|
||||
{#if rewritten !== undefined && rewritten === latest.current}
|
||||
<Button
|
||||
variant="outline"
|
||||
styleHeight="1.75rem"
|
||||
title="The branch's history was rewritten. Show the latest."
|
||||
onclick={() => void router.replace(baseRoute)}>
|
||||
<Icon name="refresh" />
|
||||
Newer commits
|
||||
</Button>
|
||||
{/if}
|
||||
{/snippet}
|
||||
{#snippet extra()}
|
||||
<FuzzySearch
|
||||
hasItems={list.items.length > 0}
|
||||
@@ -184,6 +274,7 @@
|
||||
<VirtualList
|
||||
items={commitRows}
|
||||
hasMore={list.more}
|
||||
keepRowsOnPrepend={searchInput === ""}
|
||||
loadingMore={list.loadingMore}
|
||||
onLoadMore={() => list.loadMore()}
|
||||
getKey={r =>
|
||||
|
||||
@@ -5,14 +5,12 @@
|
||||
import type { Blob } from "@bindings/source/Blob";
|
||||
import type { Tree } from "@bindings/source/Tree";
|
||||
|
||||
import { keys } from "@radicle-gui/core/keys";
|
||||
import { createQuery } from "@radicle-gui/ui/lib/query.svelte";
|
||||
import { toHtml } from "hast-util-to-html";
|
||||
import { capitalize } from "lodash";
|
||||
import { useOverlayScrollbars } from "overlayscrollbars-svelte";
|
||||
|
||||
import { invoke, InvokeError } from "@app/lib/invoke";
|
||||
import { queryClient } from "@app/lib/query";
|
||||
import { latestHead } from "@app/lib/latestHead.svelte";
|
||||
import * as router from "@app/lib/router";
|
||||
import type { SidebarData } from "@app/lib/router/definitions";
|
||||
import { highlight } from "@app/lib/syntax";
|
||||
@@ -64,33 +62,9 @@
|
||||
revision,
|
||||
});
|
||||
|
||||
// The commit the shown revision resolves to now. A branch, or the default
|
||||
// branch without a revision, can move on while the user reads, so the page
|
||||
// keeps showing `oid` and offers the newer commit.
|
||||
const headKey = $derived(keys.head(repo.rid, peer, revision));
|
||||
// The loader has just resolved the revision, so that is the latest commit.
|
||||
// A ref update during the load may have moved it since, so then the head is
|
||||
// checked again at mount, and a push during the load still shows as newer.
|
||||
$effect.pre(() => {
|
||||
queryClient.setQueryData(headKey, oid);
|
||||
const loaded = keys.headLoaded(repo.rid, peer, revision);
|
||||
if (queryClient.getQueryState(loaded)?.isInvalidated) {
|
||||
void queryClient.invalidateQueries({ queryKey: headKey, exact: true });
|
||||
}
|
||||
});
|
||||
const head = createQuery<string>(queryClient, () => ({
|
||||
queryKey: headKey,
|
||||
queryFn: async () =>
|
||||
(
|
||||
await invoke<Commit>("repo_commit", {
|
||||
rid: repo.rid,
|
||||
peer,
|
||||
revision,
|
||||
})
|
||||
).id,
|
||||
}));
|
||||
const head = latestHead(() => ({ rid: repo.rid, peer, revision, oid }));
|
||||
const newerCommit = $derived(
|
||||
head.current.data !== undefined && head.current.data !== oid,
|
||||
head.current !== undefined && head.current !== oid,
|
||||
);
|
||||
|
||||
let currentPath = $state("");
|
||||
|
||||
@@ -445,16 +445,15 @@ export async function loadRepoHome(
|
||||
export async function loadRepoCommits(
|
||||
route: RepoCommitsRoute,
|
||||
): Promise<LoadedRepoCommitsRoute> {
|
||||
const [context, commits] = await Promise.all([
|
||||
loadSourceContext(route),
|
||||
invoke<PaginatedQuery<Commit[]>>("list_repo_commits", {
|
||||
rid: route.rid,
|
||||
peer: route.peer,
|
||||
revision: route.revision,
|
||||
skip: 0,
|
||||
take: COMMITS_PAGE_SIZE,
|
||||
}),
|
||||
]);
|
||||
// The list pages from the commit the context resolved, so that the two
|
||||
// agree even when the branch moves during the load.
|
||||
const context = await loadSourceContext(route);
|
||||
const commits = await invoke<PaginatedQuery<Commit[]>>("list_repo_commits", {
|
||||
rid: route.rid,
|
||||
head: context.oid,
|
||||
skip: 0,
|
||||
take: COMMITS_PAGE_SIZE,
|
||||
});
|
||||
|
||||
return {
|
||||
resource: "repo.commits",
|
||||
|
||||
@@ -0,0 +1,64 @@
|
||||
import { describe, expect, test } from "vitest";
|
||||
|
||||
import { newerCommits } from "@app/lib/newerCommits";
|
||||
|
||||
function commit(id: string, parents = ["p"]) {
|
||||
return { id, parents };
|
||||
}
|
||||
|
||||
// A branch's history from its head, newest first, paged like the backend.
|
||||
function history(...commits: { id: string; parents: string[] }[]) {
|
||||
return async (skip: number, take: number) => ({
|
||||
cursor: skip,
|
||||
content: commits.slice(skip, skip + take),
|
||||
more: skip + take < commits.length,
|
||||
});
|
||||
}
|
||||
|
||||
describe("newerCommits", () => {
|
||||
test("returns the commits before the old head", async () => {
|
||||
const fetch = history(commit("c"), commit("b"), commit("a"));
|
||||
expect(await newerCommits(fetch, "a", 100, 10)).toEqual({
|
||||
type: "added",
|
||||
commits: [commit("c"), commit("b")],
|
||||
merge: false,
|
||||
});
|
||||
});
|
||||
|
||||
test("follows pages until it finds the old head", async () => {
|
||||
const fetch = history(commit("d"), commit("c"), commit("b"), commit("a"));
|
||||
const result = await newerCommits(fetch, "a", 100, 2);
|
||||
expect(result).toEqual({
|
||||
type: "added",
|
||||
commits: [commit("d"), commit("c"), commit("b")],
|
||||
merge: false,
|
||||
});
|
||||
});
|
||||
|
||||
test("says when a merge brought in older commits", async () => {
|
||||
const fetch = history(commit("m", ["a", "x"]), commit("a"));
|
||||
const result = await newerCommits(fetch, "a", 100, 10);
|
||||
expect(result).toMatchObject({ type: "added", merge: true });
|
||||
});
|
||||
|
||||
test("an unmoved head adds nothing", async () => {
|
||||
const fetch = history(commit("a"));
|
||||
expect(await newerCommits(fetch, "a", 100, 10)).toEqual({
|
||||
type: "added",
|
||||
commits: [],
|
||||
merge: false,
|
||||
});
|
||||
});
|
||||
|
||||
test("history without the old head was rewritten", async () => {
|
||||
const fetch = history(commit("c"), commit("b"));
|
||||
expect(await newerCommits(fetch, "a", 100, 10)).toEqual({
|
||||
type: "rewritten",
|
||||
});
|
||||
});
|
||||
|
||||
test("gives up past the limit", async () => {
|
||||
const fetch = history(commit("d"), commit("c"), commit("b"), commit("a"));
|
||||
expect(await newerCommits(fetch, "a", 2, 2)).toEqual({ type: "rewritten" });
|
||||
});
|
||||
});
|
||||
@@ -359,6 +359,32 @@ test("a refresh started on a key change isn't undone by the list's reset", async
|
||||
await vi.waitFor(() => expect(list.items).toEqual(["fresh"]));
|
||||
});
|
||||
|
||||
test("rows added at the top move the paging offset along", async () => {
|
||||
const { list } = setup(page(["c", "d"]));
|
||||
list.prepend(["a", "b"]);
|
||||
fetchPage.mockResolvedValueOnce(page(["e"], false));
|
||||
|
||||
await list.loadMore();
|
||||
|
||||
expect(list.items).toEqual(["a", "b", "c", "d", "e"]);
|
||||
expect(fetchPage).toHaveBeenLastCalledWith(4, 2);
|
||||
});
|
||||
|
||||
test("a replacing load that was in flight across a prepend is fetched again", async () => {
|
||||
const { list } = setup(page(["c", "d"]));
|
||||
const stale = deferred();
|
||||
fetchPage.mockReturnValueOnce(stale.promise);
|
||||
fetchPage.mockResolvedValueOnce(page(["a", "b", "c", "d"], false));
|
||||
|
||||
const loading = list.loadMore(true);
|
||||
list.prepend(["a", "b"]);
|
||||
stale.resolve(page(["c", "d"], false));
|
||||
await loading;
|
||||
|
||||
expect(list.items).toEqual(["a", "b", "c", "d"]);
|
||||
expect(fetchPage).toHaveBeenCalledTimes(2);
|
||||
});
|
||||
|
||||
test("a refresh during a page load leaves the list able to load more", async () => {
|
||||
const { list } = setup();
|
||||
const pageLoad = deferred();
|
||||
|
||||
Reference in New Issue
Block a user