Skip to content

armgit / ente

Public Imported from GitHub
0

πŸ’š End-to-end encrypted cloud for everything.

Restore post grids and latest feed behavior

Anand Baburajan05311150ed53
diff --git a/web/apps/space/src/components/PostGrid.tsx b/web/apps/space/src/components/PostGrid.tsx
new file mode 100644
index 0000000000..9f0216400f
--- /dev/null
+++ b/web/apps/space/src/components/PostGrid.tsx
@@ -0,0 +1,91 @@
+import { Box } from "@mui/material";
+import React from "react";
+import { minimumPostPhotoFrameAspectRatio } from "styles/tiles";
+
+const gap = 8;
+
+interface PostGridItem {
+ id: string;
+ frameAspectRatio?: number;
+ width?: number;
+ height?: number;
+}
+
+export const SpacePostGrid = <Item extends PostGridItem>({
+ items,
+ postCount,
+ renderTile,
+}: {
+ items: Item[];
+ postCount?: number;
+ renderTile: (item: Item, index: number) => React.ReactNode;
+}) => {
+ const [width, setWidth] = React.useState(0);
+ const gridRef = React.useRef<HTMLDivElement | null>(null);
+
+ React.useLayoutEffect(() => {
+ const grid = gridRef.current!;
+ const observer = new ResizeObserver(([entry]) =>
+ setWidth(entry!.contentRect.width),
+ );
+ setWidth(grid.getBoundingClientRect().width);
+ observer.observe(grid);
+ return () => observer.disconnect();
+ }, []);
+
+ const fullWidth =
+ postCount != undefined && Math.max(postCount, items.length) < 4;
+
+ const columnCount = fullWidth ? 1 : 2;
+ const columnWidth = (width - (columnCount - 1) * gap) / columnCount;
+ const columnHeights = new Array<number>(columnCount).fill(0);
+ const tiles =
+ width > gap
+ ? items.map((item, index) => {
+ const column =
+ fullWidth || columnHeights[0]! <= columnHeights[1]!
+ ? 0
+ : 1;
+ const top = columnHeights[column]!;
+ const photoAspectRatio =
+ item.frameAspectRatio ??
+ (item.width && item.height
+ ? item.width / item.height
+ : 1);
+ const aspectRatio = Math.max(
+ minimumPostPhotoFrameAspectRatio,
+ photoAspectRatio,
+ );
+ const height = columnWidth / aspectRatio;
+ columnHeights[column] = top + height + gap;
+ return (
+ <Box
+ key={item.id}
+ sx={{
+ height,
+ left: column * (columnWidth + gap),
+ position: "absolute",
+ top,
+ width: columnWidth,
+ }}
+ >
+ {renderTile(item, index)}
+ </Box>
+ );
+ })
+ : [];
+
+ return (
+ <Box
+ ref={gridRef}
+ sx={{
+ height:
+ Math.max(0, ...columnHeights) - (tiles.length ? gap : 0),
+ position: "relative",
+ width: "100%",
+ }}
+ >
+ {tiles}
+ </Box>
+ );
+};
diff --git a/web/apps/space/src/components/PostTile.tsx b/web/apps/space/src/components/PostTile.tsx
index cd6fb8752e..afd02da1af 100644
--- a/web/apps/space/src/components/PostTile.tsx
+++ b/web/apps/space/src/components/PostTile.tsx
@@ -1,19 +1,17 @@
import { Box } from "@mui/material";
-import { SpaceCaptionText } from "components/CaptionText";
+import { SpacePostAvatar } from "components/PostAvatar";
import {
SpacePostPhotosBadge,
SpacePostVideoBadge,
} from "components/PostPhotosBadge";
import { viewerOriginKey } from "components/viewer-transition";
import log from "ente-base/log";
+import { useDecodedImage } from "hooks/use-decoded-image";
import React from "react";
import type { SpacePostAsset, SpacePostPhoto } from "services/space";
import { spaceSurface, spaceTextMuted } from "styles/colors";
-import {
- minimumPostPhotoFrameAspectRatio,
- spaceProfilePostRadius,
-} from "styles/tiles";
-import { formatSpaceDate } from "utils/display";
+import { spaceProfilePostRadius } from "styles/tiles";
+import { spaceTouchTargetSize } from "styles/touch-targets";
import { thumbHashDataURLFromBase64 } from "utils/thumbhash";
const green = "#08C225";
@@ -39,34 +37,48 @@ export interface SpacePostTileItem {
interface SpacePostTileProps {
displayName: string;
+ showAvatar?: boolean;
+ subtlePhotosBadge?: boolean;
+ onLoadAvatar?: () => Promise<string | null>;
imageUrl?: string;
index: number;
+ isAvatarPending?: boolean;
isUnavailable: boolean;
item: SpacePostTileItem;
loadRootMargin: string;
onImageDecodeError: () => void;
onLoadImage: () => Promise<string | undefined>;
onOpen: (imageUrl: string) => void;
+ onOpenProfile?: () => void;
onRememberDimensions?: (itemID: string, image: HTMLImageElement) => void;
photoIndex?: number;
}
export const SpacePostTile: React.FC<SpacePostTileProps> = ({
displayName,
+ showAvatar = false,
+ subtlePhotosBadge,
+ onLoadAvatar,
imageUrl,
index,
+ isAvatarPending = false,
isUnavailable: isPostUnavailable,
item,
loadRootMargin,
onImageDecodeError,
onLoadImage,
onOpen,
+ onOpenProfile,
onRememberDimensions,
photoIndex = 0,
}) => {
const [shouldLoad, setShouldLoad] = React.useState(Boolean(imageUrl));
const [readyImageUrl, setReadyImageUrl] = React.useState<string>();
const [failedImageUrl, setFailedImageUrl] = React.useState<string>();
+ const decodedAvatar = useDecodedImage(
+ showAvatar ? item.avatarUrl : undefined,
+ true,
+ );
const tileRef = React.useRef<HTMLButtonElement | null>(null);
const shownPhoto = item.photos?.[photoIndex];
const thumbHash = photoIndex > 0 ? shownPhoto?.thumbHash : item.thumbHash;
@@ -78,11 +90,6 @@ export const SpacePostTile: React.FC<SpacePostTileProps> = ({
const isUnavailable =
isPostUnavailable || Boolean(imageUrl && failedImageUrl == imageUrl);
const photoCount = item.photos?.length ?? 1;
- const caption = item.caption?.trim();
- const aspectRatio = Math.max(
- minimumPostPhotoFrameAspectRatio,
- item.width && item.height ? item.width / item.height : 1,
- );
React.useEffect(() => {
if (imageUrl) setShouldLoad(true);
@@ -122,17 +129,19 @@ export const SpacePostTile: React.FC<SpacePostTileProps> = ({
});
}, [imageUrl, isUnavailable, onLoadImage, shouldLoad]);
+ React.useEffect(() => {
+ if (shouldLoad && !isUnavailable) void onLoadAvatar?.();
+ }, [isUnavailable, onLoadAvatar, shouldLoad]);
+
return (
<Box
- component="article"
sx={{
- aspectRatio,
bgcolor: spaceSurface,
borderRadius: `${spaceProfilePostRadius}px`,
+ height: "100%",
minWidth: 0,
overflow: "hidden",
position: "relative",
- width: "100%",
}}
>
<Box
@@ -248,74 +257,17 @@ export const SpacePostTile: React.FC<SpacePostTileProps> = ({
) : null}
{!isUnavailable && (
<>
- <Box
- aria-hidden
- data-space-viewer-header-shade
- sx={{
- background:
- "linear-gradient(180deg, rgba(0, 0, 0, 0.78), rgba(0, 0, 0, 0))",
- filter: "blur(12px)",
- height: 100,
- left: -12,
- pointerEvents: "none",
- position: "absolute",
- right: -12,
- top: -12,
- }}
+ <SpacePostPhotosBadge
+ count={photoCount}
+ inset={8}
+ subtle={subtlePhotosBadge}
/>
- <Box
- component="time"
- data-space-viewer-header
- dateTime={new Date(item.timestampMs).toISOString()}
- sx={{
- color: "#D9D9D9",
- fontFamily:
- '"Inter Variable", Inter, sans-serif',
- fontSize: 12,
- fontWeight: 500,
- left: 16,
- lineHeight: "16px",
- pointerEvents: "none",
- position: "absolute",
- top: 16,
- }}
- >
- {formatSpaceDate(item.timestampMs)}
- </Box>
- <SpacePostPhotosBadge count={photoCount} inset={12} />
<SpacePostVideoBadge
durationMs={
item.photos?.[photoIndex]?.video?.durationMs
}
size={18}
/>
- {caption && (
- <Box
- title={caption}
- sx={{
- bottom: 20,
- color: "#E6E6E6",
- fontFamily:
- '"Inter Variable", Inter, sans-serif',
- fontSize: 13,
- fontWeight: 600,
- left: "50%",
- lineHeight: "21px",
- maxWidth: "78%",
- pointerEvents: "none",
- position: "absolute",
- textAlign: "center",
- textWrap: "balance",
- transform: "translateX(-50%)",
- width: "max-content",
- }}
- >
- <SpaceCaptionText
- caption={caption}
- lineClamp={2}
- />
- </Box>
- )}
</>
)}
{isUnavailable && (
@@ -335,6 +287,43 @@ export const SpacePostTile: React.FC<SpacePostTileProps> = ({
</Box>
)}
</Box>
+ {showAvatar && (
+ <Box
+ component="button"
+ type="button"
+ aria-label={`Open ${displayName}'s profile`}
+ data-space-viewer-avatar
+ disabled={!onOpenProfile}
+ onClick={onOpenProfile}
+ sx={{
+ alignItems: "flex-end",
+ appearance: "none",
+ bgcolor: "transparent",
+ border: 0,
+ borderRadius: "50%",
+ bottom: 0,
+ cursor: onOpenProfile ? "pointer" : "default",
+ display: "flex",
+ height: spaceTouchTargetSize,
+ left: 0,
+ p: "0 0 8px 8px",
+ position: "absolute",
+ width: spaceTouchTargetSize,
+ "&:focus-visible": {
+ outline: `2px solid ${green}`,
+ outlineOffset: -2,
+ },
+ }}
+ >
+ <SpacePostAvatar
+ ready={!isAvatarPending && decodedAvatar.ready}
+ size={26}
+ src={
+ decodedAvatar.failed ? undefined : decodedAvatar.src
+ }
+ />
+ </Box>
+ )}
</Box>
);
};
diff --git a/web/apps/space/src/pages/app/index.tsx b/web/apps/space/src/pages/app/index.tsx
index 971dd03cec..c89c57aec6 100644
--- a/web/apps/space/src/pages/app/index.tsx
+++ b/web/apps/space/src/pages/app/index.tsx
@@ -8,6 +8,8 @@ import {
cacheCurrentSpaceFeedPage,
loadCachedSpaceFeed,
loadSpaceFeedSession,
+ rememberSpaceFeedSessionPosts,
+ spaceFeedSessionItems,
type SpaceFeedSession,
} from "services/feed-cache";
import { consumeSentSpaceInviteFriend, spaceInviteURL } from "services/invite";
@@ -115,6 +117,7 @@ const Page: React.FC = () => {
const isCancelled = () => request.cancelled;
let loadedSpaceId: string | undefined;
let cachedFeedSyncedAtMs: number | undefined;
+ let loadedFeedSession: SpaceFeedSession | undefined;
setSpaceId(undefined);
setFeedItems([]);
setFeedSession(undefined);
@@ -129,9 +132,12 @@ const Page: React.FC = () => {
const session = await loadSpaceFeedSession(spaceId);
const cachedFeed = await loadCachedSpaceFeed(spaceId);
if (isCancelled()) return;
+ loadedFeedSession = session;
setFeedSession(session);
cachedFeedSyncedAtMs = cachedFeed?.syncedAtMs;
- setFeedItems(cachedFeed?.items ?? []);
+ setFeedItems(
+ spaceFeedSessionItems(session, cachedFeed?.items ?? []),
+ );
setFeedNextCursor(
cachedFeed?.dirty ? undefined : cachedFeed?.nextCursor,
);
@@ -151,12 +157,14 @@ const Page: React.FC = () => {
}
if (savedSpaceId != nextSpaceId) await loadCache(nextSpaceId);
while (!isCancelled()) {
+ const feedRequestedAtMs = Date.now();
const feed = await loadCurrentFeedPage(nextSpaceId);
if (isCancelled()) return undefined;
const applied = await cacheCurrentSpaceFeedPage(
nextSpaceId,
feed,
{ syncedAtMs: cachedFeedSyncedAtMs },
+ feedRequestedAtMs,
);
if (applied) return feed;
cachedFeedSyncedAtMs = (await loadCachedSpaceFeed(nextSpaceId))
@@ -167,7 +175,9 @@ const Page: React.FC = () => {
.then((feed) => {
if (isCancelled() || !loadedSpaceId || !feed) return;
- setFeedItems(feed.items);
+ setFeedItems(
+ spaceFeedSessionItems(loadedFeedSession, feed.items),
+ );
setFeedNextCursor(feed.nextCursor);
const refreshedPostIDs = new Set(
feed.items.map((item) => item.postId),
@@ -217,6 +227,7 @@ const Page: React.FC = () => {
setIsFeedLoadingMore(true);
try {
const feed = await loadCurrentFeedPage(spaceId, feedNextCursor);
+ await rememberSpaceFeedSessionPosts(spaceId, feed.items);
setFeedItems((currentItems) => {
const existingPostIds = new Set(
currentItems.map((item) => item.postId),
@@ -408,6 +419,7 @@ const Page: React.FC = () => {
try {
if (status == "friend") {
clearSpaceFriendsCache();
+ const feedRequestedAtMs = Date.now();
const [requests, friends, feed] =
await Promise.all([
loadCurrentFriendRequests(actorSpaceId),
@@ -419,8 +431,15 @@ const Page: React.FC = () => {
await cacheCurrentSpaceFeedPage(
actorSpaceId,
feed,
+ undefined,
+ feedRequestedAtMs,
+ );
+ setFeedItems(
+ spaceFeedSessionItems(
+ feedSession,
+ feed.items,
+ ),
);
- setFeedItems(feed.items);
setFeedNextCursor(feed.nextCursor);
} else {
setFriendRequests(
diff --git a/web/apps/space/src/screens/HomeScreen.tsx b/web/apps/space/src/screens/HomeScreen.tsx
index 28f0c75390..6c0b8d0212 100644
--- a/web/apps/space/src/screens/HomeScreen.tsx
+++ b/web/apps/space/src/screens/HomeScreen.tsx
@@ -30,9 +30,11 @@ import {
} from "components/post-like-animation";
import { paintStretchingDot } from "components/post-photos-dots";
import { SpacePostAvatar } from "components/PostAvatar";
+import { SpacePostGrid } from "components/PostGrid";
import { SpacePostLikeHeart } from "components/PostLikeHeart";
import { SpacePostPhotosCounter } from "components/PostPhotosCounter";
import { SpacePostPhotosDots } from "components/PostPhotosDots";
+import { SpacePostTile } from "components/PostTile";
import { SpacePWAInstallPrompt } from "components/PWAInstallPrompt";
import { SpaceLoadingSpinner } from "components/RouteFallback";
import { SpaceShareInviteButton } from "components/ShareInviteButton";
@@ -163,7 +165,6 @@ interface FeedLayoutSnapshot {
interface FeedMotionListProps {
entries: HomeFeedEntry[];
presentedPostIdentities?: Set<string>;
- separatorBefore?: string;
renderEntry: (entry: HomeFeedEntry) => React.ReactNode;
}
@@ -239,10 +240,14 @@ class FeedMotionList extends React.Component<FeedMotionListProps> {
const firstRetainedIndex = this.props.entries.findIndex((entry) =>
previousIdentities.has(entry.identity),
);
+ const enteringCount =
+ previousProps.entries.length == 0
+ ? this.props.entries.length
+ : firstRetainedIndex;
const enteringKeys = new Set(
- firstRetainedIndex > 0
+ enteringCount > 0
? this.props.entries
- .slice(0, firstRetainedIndex)
+ .slice(0, enteringCount)
.filter((entry) => entry.kind == "remote")
.filter(
(entry) =>
@@ -259,6 +264,18 @@ class FeedMotionList extends React.Component<FeedMotionListProps> {
}
componentDidMount() {
+ this.animateFrom({
+ enteringKeys: new Set(
+ this.props.entries
+ .filter((entry) => entry.kind == "remote")
+ .filter(
+ (entry) =>
+ !this.presentedPostIdentities.has(entry.identity),
+ )
+ .map(this.stableKeyFor),
+ ),
+ previousTops: new Map(),
+ });
this.rememberPresentedPosts();
}
@@ -372,36 +389,6 @@ class FeedMotionList extends React.Component<FeedMotionListProps> {
width: "100%",
}}
>
- {entry.identity == this.props.separatorBefore && (
- <Box
- role="separator"
- aria-label="Earlier posts"
- sx={{
- alignItems: "center",
- color: spaceTextMuted,
- display: "flex",
- height: 36,
- justifyContent: "center",
- mb: "12px",
- }}
- >
- <svg
- aria-hidden="true"
- width="116"
- height="12"
- viewBox="0 0 116 12"
- fill="none"
- >
- <path
- d="M4 6 Q10 -2 16 6 T28 6 T40 6 T52 6 T64 6 T76 6 T88 6 T100 6 T112 6"
- stroke="currentColor"
- strokeOpacity="0.6"
- strokeWidth="2.5"
- strokeLinecap="round"
- />
- </svg>
- </Box>
- )}
{this.props.renderEntry(entry)}
</Box>
);
@@ -1955,8 +1942,16 @@ export const HomeScreen: React.FC<HomeScreenProps> = ({
const selectedPhotoFriendID = selectedViewer?.photo.friendID;
const selectedPhotoIsOwn =
Boolean(viewerSpaceId) && selectedPhotoFriendID == viewerSpaceId;
- const feedEntries = homeFeedEntries(feedItems, localFeedPosts);
- const hasFeedItems = feedEntries.length > 0;
+ const { latest: latestFeedEntries, history: gridFeedItems } =
+ homeFeedEntries(
+ feedItems,
+ localFeedPosts,
+ feedSession?.newPostsSinceMs,
+ new Set(feedSession?.latestPosts.map((post) => post.postId)),
+ viewerSpaceId,
+ );
+ const hasFeedItems =
+ latestFeedEntries.length > 0 || gridFeedItems.length > 0;
const isEmptyFeedLoading = !hasFeedItems && isFeedLoading;
const showFeedCards = hasFeedItems;
const isInstallPromptEnabled =
@@ -2326,23 +2321,178 @@ export const HomeScreen: React.FC<HomeScreenProps> = ({
>
{hasFeedItems ? (
<>
- <FeedMotionList
- entries={feedEntries}
- separatorBefore={homeFeedSeparatorBefore(
- feedEntries,
- feedSession?.previousNewestPost,
- )}
- presentedPostIdentities={
- feedSession?.presentedPostIdentities
- }
- renderEntry={(entry) =>
- entry.kind == "local"
- ? localFeedItemFor(entry.item)
- : feedItemFor(
- entry.item,
- entry.item.postId,
- )
+ <Box
+ component="section"
+ aria-label="Latest"
+ hidden={latestFeedEntries.length == 0}
+ >
+ <FeedMotionList
+ entries={latestFeedEntries}
+ presentedPostIdentities={
+ feedSession?.presentedPostIdentities
+ }
+ renderEntry={(entry) =>
+ entry.kind == "local"
+ ? localFeedItemFor(entry.item)
+ : feedItemFor(
+ entry.item,
+ entry.item.postId,
+ )
+ }
+ />
+ </Box>
+ {homeFeedSeparatorBefore(
+ latestFeedEntries,
+ gridFeedItems,
+ ) && (
+ <Box
+ role="separator"
+ aria-label="Earlier posts"
+ sx={{
+ alignItems: "center",
+ color: spaceTextMuted,
+ display: "flex",
+ height: 36,
+ justifyContent: "center",
+ mb: "12px",
+ }}
+ >
+ <svg
+ aria-hidden="true"
+ width="116"
+ height="12"
+ viewBox="0 0 116 12"
+ fill="none"
+ >
+ <path
+ d="M4 6 Q10 -2 16 6 T28 6 T40 6 T52 6 T64 6 T76 6 T88 6 T100 6 T112 6"
+ stroke="currentColor"
+ strokeOpacity="0.6"
+ strokeWidth="2.5"
+ strokeLinecap="round"
+ />
+ </svg>
+ </Box>
+ )}
+ <SpacePostGrid
+ postCount={
+ latestFeedEntries.length +
+ gridFeedItems.length
}
+ items={gridFeedItems.map((item) => {
+ const photo = spacePostPhotos(item)[0]!;
+ return {
+ ...item,
+ id: String(item.postId),
+ frameAspectRatio:
+ photo.width && photo.height
+ ? photo.width / photo.height
+ : 1,
+ };
+ })}
+ renderTile={(item, index) => {
+ const postPhotos = spacePostPhotos(item);
+ const photoAt = (index: number) => ({
+ ...postPhotos[index]!,
+ postId: item.postId,
+ spaceId: item.spaceId,
+ });
+ const remembered = Math.min(
+ feedPhotoIndices[item.postId] ?? 0,
+ postPhotos.length - 1,
+ );
+ const photoIndex =
+ remembered > 0 &&
+ unavailableFeedPostsByKey[
+ feedPostImageCacheKey(
+ photoAt(remembered),
+ )
+ ]
+ ? 0
+ : remembered;
+ const photo = photoAt(photoIndex);
+ const imageUrl =
+ loadedFeedImageURLFor(photo);
+ const avatarUrl =
+ loadedFeedAvatarURLFor(item);
+ const isUnavailable = Boolean(
+ item.isUnavailable ||
+ unavailableFeedPostsByKey[
+ feedPostImageCacheKey(photo)
+ ],
+ );
+ const isOwnPost =
+ Boolean(viewerSpaceId) &&
+ item.spaceId == viewerSpaceId;
+ return (
+ <SpacePostTile
+ key={item.id}
+ item={{ ...item, avatarUrl }}
+ photoIndex={photoIndex}
+ displayName={item.name}
+ showAvatar
+ subtlePhotosBadge
+ index={index}
+ imageUrl={imageUrl}
+ isAvatarPending={
+ !item.isUnavailable &&
+ avatarUrl === undefined
+ }
+ isUnavailable={isUnavailable}
+ loadRootMargin={
+ feedMediaLoadRootMargin
+ }
+ onOpenProfile={
+ isOwnPost
+ ? onOpenProfile
+ : onOpenFriend
+ ? () =>
+ onOpenFriend(
+ item.friendID,
+ item.username,
+ )
+ : undefined
+ }
+ onLoadAvatar={
+ avatarUrl === undefined
+ ? () =>
+ loadFeedPostAvatar(
+ item,
+ )
+ : undefined
+ }
+ onLoadImage={() =>
+ loadFeedPostImage(photo)
+ }
+ onImageDecodeError={() =>
+ setUnavailableFeedPostsByKey(
+ (current) => ({
+ ...current,
+ [feedPostImageCacheKey(
+ photo,
+ )]: true,
+ }),
+ )
+ }
+ onOpen={(imageUrl) => {
+ const post = {
+ ...item,
+ avatarUrl,
+ imageUrl:
+ photoIndex == 0
+ ? imageUrl
+ : item.imageUrl,
+ };
+ openFeedPhoto(post, {
+ ...viewerPhotosFromPost(
+ post,
+ )[photoIndex]!,
+ imageUrl,
+ });
+ }}
+ />
+ );
+ }}
/>
{hasMoreFeedItems && onLoadMoreFeedItems && (
<Box
diff --git a/web/apps/space/src/screens/ProfileScreen.tsx b/web/apps/space/src/screens/ProfileScreen.tsx
index 983d42453b..80c5993c4e 100644
--- a/web/apps/space/src/screens/ProfileScreen.tsx
+++ b/web/apps/space/src/screens/ProfileScreen.tsx
@@ -25,6 +25,7 @@ import {
type SpaceViewerPhoto,
type SpaceViewerPostActionMode,
} from "components/FileViewer";
+import { SpacePostGrid } from "components/PostGrid";
import { SpacePostPhotoInput } from "components/PostPhotoInput";
import { SpacePostTile, type SpacePostTileItem } from "components/PostTile";
import { SpaceLoadingSpinner } from "components/RouteFallback";
@@ -1354,7 +1355,14 @@ export const ProfileScreen: React.FC<ProfileScreenProps> = ({
width: "calc(100% - 16px)",
}}
>
- {visiblePostItems.map(renderPostTile)}
+ <SpacePostGrid
+ items={visiblePostItems.map((item) => ({
+ ...item,
+ ...dimensionsForPost(item),
+ }))}
+ postCount={displayedPostsCount}
+ renderTile={renderPostTile}
+ />
</Box>
) : shouldShowPostLoadingIndicator ? (
<ProfilePostLoadingIndicator />
diff --git a/web/apps/space/src/services/feed-cache.ts b/web/apps/space/src/services/feed-cache.ts
index a1f79e7dc5..e6e40d4525 100644
--- a/web/apps/space/src/services/feed-cache.ts
+++ b/web/apps/space/src/services/feed-cache.ts
@@ -12,6 +12,7 @@ const spaceFeedCacheSize = 20;
const SpaceFeedCacheSnapshotSchema = z.object({
dirty: z.boolean(),
items: CachedSpacePost.array(),
+ lastVisitedAtMs: z.number().optional(),
nextCursor: z.string().optional(),
spaceId: z.string(),
syncedAtMs: z.number(),
@@ -21,6 +22,7 @@ const SpaceFeedCacheSnapshotSchema = z.object({
export interface SpaceFeedCacheSnapshot {
dirty: boolean;
items: SpacePost[];
+ lastVisitedAtMs?: number;
nextCursor?: string;
spaceId: string;
syncedAtMs: number;
@@ -28,14 +30,16 @@ export interface SpaceFeedCacheSnapshot {
}
export interface SpaceFeedSession {
+ newPostsSinceMs: number;
+ latestPosts: SpacePost[];
presentedPostIdentities: Set<string>;
- previousNewestPost?: Pick<SpacePost, "postId" | "timestampMs">;
}
const memoryCache = new Map<string, SpaceFeedCacheSnapshot | undefined>();
const feedSessions = new Map<string, SpaceFeedSession>();
const cacheOperations = new Map<string, Promise<void>>();
let cacheGeneration = 0;
+let appOpenedAtMs = Date.now();
const cacheKey = async (spaceId: string) => {
const userID = savedPartialLocalUser()?.id;
@@ -141,29 +145,67 @@ export const loadCachedSpaceFeed = async (
}
};
-export const loadSpaceFeedSession = async (spaceId: string) => {
- const generation = cacheGeneration;
- const key = await cacheKey(spaceId);
- if (!key || generation != cacheGeneration) return undefined;
- const cached = await loadCachedSpaceFeed(spaceId);
- if (generation != cacheGeneration) return undefined;
+const feedSessionForSnapshot = (
+ key: string,
+ cached: SpaceFeedCacheSnapshot | undefined,
+) => {
let session = feedSessions.get(key);
if (!session) {
- const newestPost = cached?.items[0];
+ const newPostsSinceMs = cached?.lastVisitedAtMs ?? appOpenedAtMs;
session = {
+ newPostsSinceMs,
+ latestPosts: (cached?.items ?? []).filter(
+ (post) =>
+ post.spaceId != cached?.spaceId &&
+ post.timestampMs > newPostsSinceMs,
+ ),
presentedPostIdentities: new Set(),
- previousNewestPost: newestPost
- ? {
- postId: newestPost.postId,
- timestampMs: newestPost.timestampMs,
- }
- : undefined,
};
feedSessions.set(key, session);
}
return session;
};
+export const loadSpaceFeedSession = async (spaceId: string) => {
+ const generation = cacheGeneration;
+ const key = await cacheKey(spaceId);
+ if (!key || generation != cacheGeneration) return undefined;
+ const cached = await loadCachedSpaceFeed(spaceId);
+ if (generation != cacheGeneration) return undefined;
+ return feedSessionForSnapshot(key, cached);
+};
+
+export const spaceFeedSessionItems = (
+ session: SpaceFeedSession | undefined,
+ items: SpacePost[],
+) =>
+ [
+ ...new Map(
+ [...(session?.latestPosts ?? []), ...items].map((post) => [
+ post.postId,
+ post,
+ ]),
+ ).values(),
+ ].sort(descendingPostOrder);
+
+const rememberSessionPosts = (
+ session: SpaceFeedSession,
+ items: SpacePost[],
+ spaceId: string,
+) => {
+ const latestPostIDs = new Set(
+ session.latestPosts.map((post) => post.postId),
+ );
+ session.latestPosts = spaceFeedSessionItems(session, items)
+ .filter(
+ (post) =>
+ (post.spaceId != spaceId &&
+ post.timestampMs > session.newPostsSinceMs) ||
+ latestPostIDs.has(post.postId),
+ )
+ .map(cacheablePost);
+};
+
const writeCachedSpaceFeed = async (
snapshot: SpaceFeedCacheSnapshot,
previous?: { syncedAtMs?: number },
@@ -179,7 +221,27 @@ const writeCachedSpaceFeed = async (
if (generation != cacheGeneration) return;
if (previous && memoryCache.get(key)?.syncedAtMs != previous.syncedAtMs)
return;
+ normalized.lastVisitedAtMs =
+ Math.max(
+ normalized.lastVisitedAtMs ?? 0,
+ memoryCache.get(key)?.lastVisitedAtMs ?? 0,
+ ) || undefined;
applied = true;
+ const session = feedSessions.get(key);
+ if (session) {
+ const refreshedPostIDs = new Set(
+ snapshot.items.map((post) => post.postId),
+ );
+ const oldestPost = snapshot.nextCursor
+ ? snapshot.items.at(-1)
+ : undefined;
+ session.latestPosts = session.latestPosts.filter(
+ (post) =>
+ refreshedPostIDs.has(post.postId) ||
+ (oldestPost && descendingPostOrder(post, oldestPost) > 0),
+ );
+ rememberSessionPosts(session, snapshot.items, snapshot.spaceId);
+ }
memoryCache.set(key, normalized);
await setKV(key, normalized);
if (generation != cacheGeneration) {
@@ -194,11 +256,13 @@ export const cacheCurrentSpaceFeedPage = async (
spaceId: string,
page: SpacePostPage,
previous?: { syncedAtMs?: number },
+ lastVisitedAtMs?: number,
) =>
writeCachedSpaceFeed(
{
dirty: false,
items: page.items,
+ lastVisitedAtMs,
nextCursor: page.nextCursor,
spaceId,
syncedAtMs: Date.now(),
@@ -244,6 +308,15 @@ const updateCachedSpaceFeed = async (
syncedAtMs: Math.max(Date.now(), snapshot.syncedAtMs + 1),
});
if (generation != cacheGeneration) return;
+ const session = createIfMissing
+ ? feedSessionForSnapshot(key, snapshot)
+ : feedSessions.get(key);
+ if (session) {
+ session.latestPosts = update({
+ ...cloneSnapshot(snapshot),
+ items: session.latestPosts.map(clonePost),
+ }).items.map(cacheablePost);
+ }
memoryCache.set(key, nextSnapshot);
await setKV(key, nextSnapshot);
if (generation != cacheGeneration) {
@@ -256,6 +329,14 @@ const updateCachedSpaceFeed = async (
const descendingPostOrder = (a: SpacePost, b: SpacePost) =>
b.timestampMs - a.timestampMs || b.postId - a.postId;
+export const rememberSpaceFeedSessionPosts = async (
+ spaceId: string,
+ posts: SpacePost[],
+) => {
+ const session = await loadSpaceFeedSession(spaceId);
+ if (session) rememberSessionPosts(session, posts, spaceId);
+};
+
export const prependCachedSpaceFeedPost = (spaceId: string, post: SpacePost) =>
updateCachedSpaceFeed(
spaceId,
@@ -313,4 +394,5 @@ export const clearSpaceFeedMemoryCache = () => {
cacheGeneration += 1;
memoryCache.clear();
feedSessions.clear();
+ appOpenedAtMs = Date.now();
};
diff --git a/web/apps/space/src/utils/home-feed.ts b/web/apps/space/src/utils/home-feed.ts
index 0f8646d54e..1b5e477c9e 100644
--- a/web/apps/space/src/utils/home-feed.ts
+++ b/web/apps/space/src/utils/home-feed.ts
@@ -10,31 +10,12 @@ export type HomeFeedEntry =
}
| { identity: string; item: SpacePost; kind: "remote"; renderKey: string };
-export const homeFeedSeparatorBefore = (
- entries: HomeFeedEntry[],
- previousNewestPost: Pick<SpacePost, "postId" | "timestampMs"> | undefined,
-) => {
- if (!previousNewestPost) return undefined;
- let hasNewPosts = false;
- for (const entry of entries) {
- if (entry.kind != "remote") continue;
- const post = entry.item;
- if (
- post.timestampMs > previousNewestPost.timestampMs ||
- (post.timestampMs == previousNewestPost.timestampMs &&
- post.postId > previousNewestPost.postId)
- ) {
- hasNewPosts = true;
- } else {
- return hasNewPosts ? entry.identity : undefined;
- }
- }
- return undefined;
-};
-
export const homeFeedEntries = (
feedItems: SpacePost[],
localFeedPosts: LocalSpaceFeedPost[],
+ newPostsSinceMs: number | undefined,
+ latestPostIDs?: ReadonlySet<number>,
+ viewerSpaceId?: string,
) => {
const localResolvedPostIds = new Set(
localFeedPosts.map((item) =>
@@ -43,7 +24,7 @@ export const homeFeedEntries = (
: item.postId,
),
);
- return [
+ const entries: HomeFeedEntry[] = [
...localFeedPosts.map((item): HomeFeedEntry => ({
identity:
item.status == "posted" || item.status == "ready"
@@ -64,4 +45,38 @@ export const homeFeedEntries = (
renderKey: `post:${item.postId}`,
})),
];
+ const latest: HomeFeedEntry[] = [];
+ const history: SpacePost[] = [];
+ for (const entry of entries) {
+ let post: SpacePost;
+ if (entry.kind == "remote") {
+ post = entry.item;
+ } else {
+ if (entry.item.status != "ready") {
+ latest.push(entry);
+ continue;
+ }
+ post = entry.item.post;
+ }
+ if (
+ latestPostIDs?.has(post.postId) ||
+ (post.spaceId != viewerSpaceId &&
+ newPostsSinceMs != undefined &&
+ post.timestampMs > newPostsSinceMs)
+ ) {
+ latest.push(entry);
+ } else {
+ history.push(post);
+ }
+ }
+ history.sort(
+ (a, b) => b.timestampMs - a.timestampMs || b.postId - a.postId,
+ );
+ return { latest, history };
};
+
+export const homeFeedSeparatorBefore = (
+ latest: HomeFeedEntry[],
+ history: SpacePost[],
+) =>
+ history.length && latest.length ? `post:${history[0]!.postId}` : undefined;
diff --git a/web/apps/space/tests/feed-cache.test.ts b/web/apps/space/tests/feed-cache.test.ts
index 3386563066..7107421b00 100644
--- a/web/apps/space/tests/feed-cache.test.ts
+++ b/web/apps/space/tests/feed-cache.test.ts
@@ -1,7 +1,7 @@
import { savedPartialLocalUser } from "ente-accounts/services/accounts-db";
import { getKV, removeKV, setKV } from "ente-base/kv";
import { apiOrigin } from "ente-base/origins";
-import { beforeEach, expect, test, vi } from "vitest";
+import { afterEach, beforeEach, expect, test, vi } from "vitest";
import {
cacheCurrentSpaceFeedPage,
clearSpaceFeedMemoryCache,
@@ -9,10 +9,13 @@ import {
loadSpaceFeedSession,
patchCachedSpaceFeedPost,
prependCachedSpaceFeedPost,
+ rememberSpaceFeedSessionPosts,
removeCachedSpaceFeedPost,
removeCachedSpaceFeedPostsBySpace,
+ spaceFeedSessionItems,
} from "../src/services/feed-cache";
import type { SpacePost } from "../src/services/space";
+import { homeFeedEntries } from "../src/utils/home-feed";
vi.mock("ente-accounts/services/accounts-db", () => ({
savedPartialLocalUser: vi.fn(),
@@ -46,6 +49,8 @@ const post = (postId: number, spaceId = "friend"): SpacePost => ({
viewerLiked: false,
});
+afterEach(() => vi.useRealTimers());
+
beforeEach(() => {
vi.resetAllMocks();
storage.clear();
@@ -112,17 +117,17 @@ test("restores all twenty posts and their cursor, then keeps the cache bounded w
expect(afterPosting.dirty).toBe(true);
});
-test("restores an existing thirty-post cache without skipping posts or retaining the visit cutoff", async () => {
- await cacheCurrentSpaceFeedPage("self", { items: [post(30)] });
+test("shrinks an existing thirty-post cache without losing the visit cutoff or skipping posts", async () => {
+ await cacheCurrentSpaceFeedPage(
+ "self",
+ { items: [post(30)] },
+ undefined,
+ 100,
+ );
const [key] = vi.mocked(setKV).mock.calls[0]!;
const snapshot = (await loadCachedSpaceFeed("self"))!;
const posts = Array.from({ length: 30 }, (_, index) => post(30 - index));
- storage.set(key, {
- ...snapshot,
- items: posts,
- nextCursor: "after-thirty",
- lastVisitedAtMs: 100,
- });
+ storage.set(key, { ...snapshot, items: posts, nextCursor: "after-thirty" });
clearSpaceFeedMemoryCache();
const restored = (await loadCachedSpaceFeed("self"))!;
expect(restored.items.map((post) => post.postId)).toEqual(
@@ -130,71 +135,8 @@ test("restores an existing thirty-post cache without skipping posts or retaining
);
expect(restored.nextCursor).toBeUndefined();
expect(restored.dirty).toBe(true);
- expect(restored).not.toHaveProperty("lastVisitedAtMs");
-});
-
-test.each([0, 2, Number.MAX_SAFE_INTEGER])(
- "legacy visit cutoff %s does not hide posts or invalidate pagination",
- async (lastVisitedAtMs) => {
- await cacheCurrentSpaceFeedPage("self", {
- items: [post(2), post(1, "self")],
- nextCursor: "older",
- });
- const [key] = vi.mocked(setKV).mock.calls[0]!;
- storage.set(key, {
- ...(await loadCachedSpaceFeed("self")),
- lastVisitedAtMs,
- });
- clearSpaceFeedMemoryCache();
-
- const restored = (await loadCachedSpaceFeed("self"))!;
- expect(restored.items.map((post) => post.postId)).toEqual([2, 1]);
- expect(restored.nextCursor).toBe("older");
- expect(restored.dirty).toBe(false);
- expect(restored).not.toHaveProperty("lastVisitedAtMs");
- },
-);
-
-test("restores mixed photo and video metadata without expired video URLs", async () => {
- const original = post(3);
- const video = {
- asset: {
- ...original.imageAsset!,
- objectKey: "video-3",
- mediaType: "video/mp4",
- },
- durationMs: 8000,
- };
- original.photos = [
- {
- imageAsset: original.imageAsset,
- width: 900,
- height: 1600,
- thumbHash: original.thumbHash,
- },
- {
- imageAsset: { ...original.imageAsset!, objectKey: "video-cover" },
- imageUrl: "blob:video-cover",
- width: 1600,
- height: 900,
- thumbHash: original.thumbHash,
- video: { ...video, url: "blob:video" },
- },
- ];
- await cacheCurrentSpaceFeedPage("self", { items: [original] });
- clearSpaceFeedMemoryCache();
-
- const restored = (await loadCachedSpaceFeed("self"))!.items[0]!;
- expect(
- restored.photos?.map(({ width, height }) => [width, height]),
- ).toEqual([
- [900, 1600],
- [1600, 900],
- ]);
- expect(restored.photos?.[1]?.video).toEqual(video);
- expect(restored.photos?.[1]?.imageAsset?.objectKey).toBe("video-cover");
- expect(restored.photos?.[1]?.thumbHash).toBe(original.thumbHash);
- expect(restored.photos?.[1]).not.toHaveProperty("imageUrl");
+ expect(restored.lastVisitedAtMs).toBe(100);
+ expect((await loadSpaceFeedSession("self"))?.newPostsSinceMs).toBe(100);
});
test("restores every photo in order and preserves shared post edits", async () => {
@@ -292,62 +234,355 @@ test("a delayed refresh cannot overwrite a publication or deletion", async () =>
).toEqual([3, 2]);
});
-test("feed entrance animations stay remembered across navigation and reset on reload", async () => {
+test("remembers the previous visit across reloads and cache mutations", async () => {
+ await cacheCurrentSpaceFeedPage("self", { items: [post(2)] });
+ expect(
+ (await loadCachedSpaceFeed("self"))?.lastVisitedAtMs,
+ ).toBeUndefined();
+ await cacheCurrentSpaceFeedPage(
+ "self",
+ { items: [post(2)] },
+ undefined,
+ 100,
+ );
+ clearSpaceFeedMemoryCache();
+ expect((await loadCachedSpaceFeed("self"))?.lastVisitedAtMs).toBe(100);
+ await prependCachedSpaceFeedPost("self", post(3, "self"));
+ await patchCachedSpaceFeedPost("self", 2, { viewerLiked: true });
+ await removeCachedSpaceFeedPost("self", 3);
+ await cacheCurrentSpaceFeedPage("self", { items: [post(2)] });
+ expect((await loadCachedSpaceFeed("self"))?.lastVisitedAtMs).toBe(100);
+ await cacheCurrentSpaceFeedPage(
+ "self",
+ { items: [post(2)] },
+ undefined,
+ 200,
+ );
+ clearSpaceFeedMemoryCache();
+ expect((await loadCachedSpaceFeed("self"))?.lastVisitedAtMs).toBe(200);
+ expect(await loadCachedSpaceFeed("other")).toBeUndefined();
+});
+
+test("a rejected refresh does not consume a visit", async () => {
+ await cacheCurrentSpaceFeedPage(
+ "self",
+ { items: [post(2)] },
+ undefined,
+ 100,
+ );
+ const cached = await loadCachedSpaceFeed("self");
+ await prependCachedSpaceFeedPost("self", post(3));
+ expect(
+ await cacheCurrentSpaceFeedPage(
+ "self",
+ { items: [post(2)] },
+ { syncedAtMs: cached?.syncedAtMs },
+ 200,
+ ),
+ ).toBe(false);
+ expect((await loadCachedSpaceFeed("self"))?.lastVisitedAtMs).toBe(100);
+});
+
+test("the latest cutoff survives navigation and advances only on a new app session", async () => {
+ await cacheCurrentSpaceFeedPage(
+ "self",
+ { items: [post(100)] },
+ undefined,
+ 100,
+ );
const session = (await loadSpaceFeedSession("self"))!;
+ expect(session.newPostsSinceMs).toBe(100);
+ await cacheCurrentSpaceFeedPage(
+ "self",
+ { items: [post(150), post(100)] },
+ undefined,
+ 200,
+ );
session.presentedPostIdentities.add("post:150");
- await cacheCurrentSpaceFeedPage("self", { items: [post(150)] });
const returned = (await loadSpaceFeedSession("self"))!;
expect(returned).toBe(session);
+ expect(returned.newPostsSinceMs).toBe(100);
+ expect(returned.latestPosts.map((post) => post.postId)).toEqual([150]);
expect(returned.presentedPostIdentities.has("post:150")).toBe(true);
clearSpaceFeedMemoryCache();
const reopened = (await loadSpaceFeedSession("self"))!;
+ expect(reopened.newPostsSinceMs).toBe(200);
+ expect(reopened.latestPosts).toEqual([]);
expect(reopened.presentedPostIdentities.size).toBe(0);
});
-test("the new-post boundary survives navigation and advances on the next reload", async () => {
- await cacheCurrentSpaceFeedPage("self", { items: [post(2), post(1)] });
+test.each(["pagination", "publication"])(
+ "%s leaves unfetched friend posts new on the next app opening",
+ async (action) => {
+ vi.useFakeTimers();
+ vi.setSystemTime(200);
+ await cacheCurrentSpaceFeedPage(
+ "self",
+ { items: [post(120)], nextCursor: "older" },
+ undefined,
+ 200,
+ );
+ const session = (await loadSpaceFeedSession("self"))!;
+ const unseenPost = post(250);
+ const ownPost = post(300, "self");
+ vi.setSystemTime(300);
+ if (action == "pagination") {
+ await rememberSpaceFeedSessionPosts("self", [post(110)]);
+ } else {
+ await prependCachedSpaceFeedPost("self", ownPost);
+ expect(session.latestPosts.map((post) => post.postId)).toEqual([
+ 300,
+ ]);
+ }
+ expect((await loadCachedSpaceFeed("self"))?.lastVisitedAtMs).toBe(200);
+
+ vi.setSystemTime(400);
+ clearSpaceFeedMemoryCache();
+ const reopened = (await loadSpaceFeedSession("self"))!;
+ const items =
+ action == "publication"
+ ? [ownPost, unseenPost, post(120)]
+ : [unseenPost, post(120)];
+ await cacheCurrentSpaceFeedPage("self", { items }, undefined, 400);
+ expect(reopened.newPostsSinceMs).toBe(200);
+ expect(reopened.latestPosts.map((post) => post.postId)).toEqual([250]);
+ expect(
+ homeFeedEntries(
+ spaceFeedSessionItems(reopened, items),
+ [],
+ reopened.newPostsSinceMs,
+ new Set(reopened.latestPosts.map((post) => post.postId)),
+ "self",
+ ).latest.map((entry) => entry.identity),
+ ).toEqual(["post:250"]);
+ expect((await loadCachedSpaceFeed("self"))?.lastVisitedAtMs).toBe(400);
+ },
+);
+
+test("returning to the feed retains more than twenty latest posts while disk caching stays bounded", async () => {
+ await cacheCurrentSpaceFeedPage(
+ "self",
+ { items: [post(100)] },
+ undefined,
+ 100,
+ );
+ const session = (await loadSpaceFeedSession("self"))!;
+ const posts = Array.from({ length: 45 }, (_, index) => post(145 - index));
+ await cacheCurrentSpaceFeedPage(
+ "self",
+ { items: posts.slice(0, 20), nextCursor: "older" },
+ undefined,
+ 200,
+ );
+ await rememberSpaceFeedSessionPosts("self", posts.slice(20));
+ await cacheCurrentSpaceFeedPage("self", {
+ items: posts.slice(0, 20),
+ nextCursor: "older",
+ });
+ expect(await loadSpaceFeedSession("self")).toBe(session);
+ expect(
+ spaceFeedSessionItems(session, posts.slice(0, 20)).map(
+ (post) => post.postId,
+ ),
+ ).toEqual(posts.map((post) => post.postId));
+ expect((await loadCachedSpaceFeed("self"))?.items).toHaveLength(20);
clearSpaceFeedMemoryCache();
+ expect((await loadCachedSpaceFeed("self"))?.items).toHaveLength(20);
+ expect((await loadSpaceFeedSession("self"))?.latestPosts).toEqual([]);
+});
+
+test.each([{ remaining: [150] }, { remaining: [] }])(
+ "a complete refresh removes deleted latest posts when remaining IDs are $remaining",
+ async ({ remaining }) => {
+ await cacheCurrentSpaceFeedPage("self", { items: [] }, undefined, 100);
+ const session = (await loadSpaceFeedSession("self"))!;
+ await cacheCurrentSpaceFeedPage("self", {
+ items: [post(150), post(140)],
+ nextCursor: "older",
+ });
+ await rememberSpaceFeedSessionPosts("self", [post(120)]);
+
+ const items = remaining.map((id) => post(id));
+ await cacheCurrentSpaceFeedPage("self", { items });
+ expect(await loadSpaceFeedSession("self")).toBe(session);
+ expect(session.latestPosts.map((post) => post.postId)).toEqual(
+ remaining,
+ );
+ expect(
+ spaceFeedSessionItems(session, items).map((post) => post.postId),
+ ).toEqual(remaining);
+ },
+);
+
+test("a partial refresh removes missing latest posts in its range and retains older pages", async () => {
+ await cacheCurrentSpaceFeedPage("self", { items: [] }, undefined, 100);
const session = (await loadSpaceFeedSession("self"))!;
- expect(session.previousNewestPost).toEqual({ postId: 2, timestampMs: 2 });
+ await cacheCurrentSpaceFeedPage("self", {
+ items: [post(160), post(150), post(140), post(130)],
+ nextCursor: "older",
+ });
+ await rememberSpaceFeedSessionPosts("self", [post(120), post(110)]);
+ session.presentedPostIdentities.add("post:150");
+ const items = [post(170), { ...post(150), caption: "Updated" }, post(130)];
+ await cacheCurrentSpaceFeedPage("self", { items, nextCursor: "older" });
+ expect(session.latestPosts.map((post) => post.postId)).toEqual([
+ 170, 150, 130, 120, 110,
+ ]);
+ expect(
+ spaceFeedSessionItems(session, items).map((post) => post.postId),
+ ).toEqual([170, 150, 130, 120, 110]);
+ expect(
+ session.latestPosts.find((post) => post.postId == 150)?.caption,
+ ).toBe("Updated");
+ expect(session.newPostsSinceMs).toBe(100);
+ expect(session.presentedPostIdentities.has("post:150")).toBe(true);
+});
+
+test("a refresh uses post IDs to distinguish posts at the same boundary timestamp", async () => {
+ await cacheCurrentSpaceFeedPage("self", { items: [] }, undefined, 100);
+ const session = (await loadSpaceFeedSession("self"))!;
await cacheCurrentSpaceFeedPage("self", {
- items: [post(4), post(3), post(2), post(1)],
+ items: [151, 150, 149].map((id) => ({ ...post(id), timestampMs: 150 })),
+ nextCursor: "older",
});
- expect(await loadSpaceFeedSession("self")).toBe(session);
- expect(session.previousNewestPost).toEqual({ postId: 2, timestampMs: 2 });
+ await rememberSpaceFeedSessionPosts("self", [post(140)]);
- clearSpaceFeedMemoryCache();
- expect((await loadSpaceFeedSession("self"))?.previousNewestPost).toEqual({
- postId: 4,
- timestampMs: 4,
+ await cacheCurrentSpaceFeedPage("self", {
+ items: [post(160), post(150)],
+ nextCursor: "older",
});
+ expect(session.latestPosts.map((post) => post.postId)).toEqual([
+ 160, 150, 149, 140,
+ ]);
});
-test("a first visit has no new-post boundary", async () => {
+test("edits and deletions from other pages update retained latest posts outside the disk cache", async () => {
+ await cacheCurrentSpaceFeedPage(
+ "self",
+ { items: [post(100)] },
+ undefined,
+ 100,
+ );
const session = (await loadSpaceFeedSession("self"))!;
- expect(session.previousNewestPost).toBeUndefined();
- await cacheCurrentSpaceFeedPage("self", { items: [post(2), post(1)] });
+ const posts = Array.from({ length: 15 }, (_, index) => post(115 - index));
+ await cacheCurrentSpaceFeedPage("self", {
+ items: posts.slice(0, 10),
+ nextCursor: "older",
+ });
+ await rememberSpaceFeedSessionPosts("self", posts.slice(10));
+ await patchCachedSpaceFeedPost("self", 101, {
+ caption: "Edited elsewhere",
+ viewerLiked: true,
+ });
expect(
- (await loadSpaceFeedSession("self"))?.previousNewestPost,
- ).toBeUndefined();
+ session.latestPosts.find((post) => post.postId == 101),
+ ).toMatchObject({ caption: "Edited elsewhere", viewerLiked: true });
+ await removeCachedSpaceFeedPost("self", 101);
+ expect(session.latestPosts.some((post) => post.postId == 101)).toBe(false);
+ await removeCachedSpaceFeedPostsBySpace("self", "friend");
+ expect(session.latestPosts).toEqual([]);
});
-test("feed animation sessions are isolated between accounts, spaces and servers", async () => {
+test("a first-session publication stays latest until the next app opening", async () => {
const session = (await loadSpaceFeedSession("self"))!;
- session.presentedPostIdentities.add("post:1");
- expect(
- (await loadSpaceFeedSession("other"))?.presentedPostIdentities.size,
- ).toBe(0);
+ const ownPost = post(session.newPostsSinceMs + 1, "self");
+ await prependCachedSpaceFeedPost("self", ownPost);
+ expect(await loadSpaceFeedSession("self")).toBe(session);
+ expect(session.latestPosts.map((post) => post.postId)).toEqual([
+ ownPost.postId,
+ ]);
+ await cacheCurrentSpaceFeedPage("self", { items: [ownPost] });
+ expect(session.latestPosts.map((post) => post.postId)).toEqual([
+ ownPost.postId,
+ ]);
+ clearSpaceFeedMemoryCache();
+ expect((await loadSpaceFeedSession("self"))?.latestPosts).toEqual([]);
+});
+
+test("latest sessions are isolated between accounts, spaces and servers", async () => {
+ const session = (await loadSpaceFeedSession("self"))!;
+ await prependCachedSpaceFeedPost("self", post(1, "self"));
+ expect((await loadSpaceFeedSession("other"))?.latestPosts).toEqual([]);
vi.mocked(savedPartialLocalUser).mockReturnValue({ id: 2 });
- expect(
- (await loadSpaceFeedSession("self"))?.presentedPostIdentities.size,
- ).toBe(0);
+ expect((await loadSpaceFeedSession("self"))?.latestPosts).toEqual([]);
vi.mocked(savedPartialLocalUser).mockReturnValue({ id: 1 });
vi.mocked(apiOrigin).mockResolvedValue("https://other.example.com");
- expect(
- (await loadSpaceFeedSession("self"))?.presentedPostIdentities.size,
- ).toBe(0);
+ expect((await loadSpaceFeedSession("self"))?.latestPosts).toEqual([]);
vi.mocked(apiOrigin).mockResolvedValue("https://api.example.com");
expect(await loadSpaceFeedSession("self")).toBe(session);
});
+
+test("restores mixed photo and video metadata without expired video URLs", async () => {
+ const original = post(3);
+ const video = {
+ asset: {
+ ...original.imageAsset!,
+ objectKey: "video-3",
+ mediaType: "video/mp4",
+ },
+ durationMs: 8000,
+ };
+ original.photos = [
+ {
+ imageAsset: original.imageAsset,
+ width: 900,
+ height: 1600,
+ thumbHash: original.thumbHash,
+ },
+ {
+ imageAsset: { ...original.imageAsset!, objectKey: "video-cover" },
+ imageUrl: "blob:video-cover",
+ width: 1600,
+ height: 900,
+ thumbHash: original.thumbHash,
+ video: { ...video, url: "blob:video" },
+ },
+ ];
+ await cacheCurrentSpaceFeedPage("self", { items: [original] });
+ clearSpaceFeedMemoryCache();
+
+ const restored = (await loadCachedSpaceFeed("self"))!.items[0]!;
+ expect(
+ restored.photos?.map(({ width, height }) => [width, height]),
+ ).toEqual([
+ [900, 1600],
+ [1600, 900],
+ ]);
+ expect(restored.photos?.[1]?.video).toEqual(video);
+ expect(restored.photos?.[1]?.imageAsset?.objectKey).toBe("video-cover");
+ expect(restored.photos?.[1]?.thumbHash).toBe(original.thumbHash);
+ expect(restored.photos?.[1]).not.toHaveProperty("imageUrl");
+});
+
+test("feed entrance animations stay remembered across navigation and reset on reload", async () => {
+ const session = (await loadSpaceFeedSession("self"))!;
+ session.presentedPostIdentities.add("post:150");
+ await cacheCurrentSpaceFeedPage("self", { items: [post(150)] });
+ const returned = (await loadSpaceFeedSession("self"))!;
+ expect(returned).toBe(session);
+ expect(returned.presentedPostIdentities.has("post:150")).toBe(true);
+
+ clearSpaceFeedMemoryCache();
+ const reopened = (await loadSpaceFeedSession("self"))!;
+ expect(reopened.presentedPostIdentities.size).toBe(0);
+});
+
+test("a cache without a visit cutoff keeps its posts and pagination on the first restored visit", async () => {
+ await cacheCurrentSpaceFeedPage("self", {
+ items: [post(2), post(1)],
+ nextCursor: "older",
+ });
+ vi.useFakeTimers();
+ vi.setSystemTime(100);
+ clearSpaceFeedMemoryCache();
+ const session = (await loadSpaceFeedSession("self"))!;
+ const cached = (await loadCachedSpaceFeed("self"))!;
+ expect(session.newPostsSinceMs).toBe(100);
+ expect(session.latestPosts).toEqual([]);
+ expect(cached.nextCursor).toBe("older");
+ expect(
+ spaceFeedSessionItems(session, cached.items).map((item) => item.postId),
+ ).toEqual([2, 1]);
+});
diff --git a/web/apps/space/tests/home-feed.test.ts b/web/apps/space/tests/home-feed.test.ts
index 3e2d4967db..586e2ef20b 100644
--- a/web/apps/space/tests/home-feed.test.ts
+++ b/web/apps/space/tests/home-feed.test.ts
@@ -15,171 +15,209 @@ const post = (postId: number, timestampMs: number): SpacePost => ({
viewerLiked: false,
});
-test("existing posts and later pages remain in one continuous feed", () => {
+test("the first visit puts all existing posts in the grid, including later pages", () => {
const posts = [post(3, 300), post(2, 200), post(1, 100)];
- const firstPage = homeFeedEntries(posts.slice(0, 2), []);
- const nextPage = homeFeedEntries(posts, []);
- expect(nextPage.slice(0, 2)).toEqual(firstPage);
- expect(nextPage.map((entry) => entry.item)).toEqual(posts);
- expect(homeFeedEntries(posts, [])).toEqual(nextPage);
+ expect(homeFeedEntries(posts, [], undefined)).toEqual({
+ latest: [],
+ history: posts,
+ });
+ expect(homeFeedEntries(posts, [], 400)).toEqual({
+ latest: [],
+ history: posts,
+ });
});
-test.each(["posted", "ready"] as const)(
- "%s uploads are not duplicated when the server returns the post",
- (status) => {
- const uploaded = post(3, 300);
- const existing = post(2, 200);
- const local: LocalSpaceFeedPost = {
- id: "upload",
- post: uploaded,
- status,
- };
- const uploading = homeFeedEntries([existing], [local]);
- const refreshed = homeFeedEntries([uploaded, existing], [local]);
- expect(refreshed).toEqual(uploading);
- expect(refreshed.map((entry) => entry.identity)).toEqual([
- "post:3",
- "post:2",
- ]);
- const resolved = homeFeedEntries([uploaded, existing], []);
- expect(resolved.map((entry) => entry.identity)).toEqual([
- "post:3",
- "post:2",
- ]);
- },
-);
-
-test.each(["pending", "failed"] as const)(
- "%s uploads remain before fetched posts and keep their identity when confirmed",
- (status) => {
- const pending = {
- caption: "Uploading",
- frameAspectRatio: 1,
- friendID: "self",
- id: "upload",
- imageUrl: "blob:preview",
- name: "Me",
- photoCount: 1,
- spaceId: "self",
- status,
- timestampMs: 300,
- } satisfies LocalSpaceFeedPost;
- const existing = post(2, 200);
- const entries = homeFeedEntries([existing], [pending]);
- expect(entries.map((entry) => entry.identity)).toEqual([
- "local:upload",
- "post:2",
- ]);
- const confirmed = homeFeedEntries(
- [post(3, 300), existing],
- [{ ...pending, postId: 3 }],
- );
- expect(confirmed.map((entry) => entry.identity)).toEqual([
- "post:3",
- "post:2",
- ]);
- expect(confirmed[0]?.renderKey).toBe(entries[0]?.renderKey);
- },
-);
+test("new posts stay full size for the visit and join history on the next visit", () => {
+ const newest = post(3, 300);
+ const existing = post(2, 200);
+ const older = post(1, 100);
+ const firstPage = homeFeedEntries([newest, existing], [], 200);
+ expect(firstPage.latest.map((entry) => entry.identity)).toEqual(["post:3"]);
+ expect(firstPage.history).toEqual([existing]);
+ const nextPage = homeFeedEntries([newest, existing, older], [], 200);
+ expect(nextPage.latest).toEqual(firstPage.latest);
+ expect(nextPage.history).toEqual([existing, older]);
+ expect(homeFeedEntries([newest, existing, older], [], 400)).toEqual({
+ latest: [],
+ history: [newest, existing, older],
+ });
+});
-test("own posts stay in the same feed after the local publication is removed", () => {
- const uploaded = { ...post(3, 300), spaceId: "self", friendID: "self" };
+test("upload completion does not duplicate a post or move it into the grid", () => {
+ const uploaded = post(3, 300);
const existing = post(2, 200);
const local: LocalSpaceFeedPost = {
id: "upload",
post: uploaded,
status: "ready",
};
- const localEntries = homeFeedEntries([uploaded, existing], [local]);
- const remoteEntries = homeFeedEntries([uploaded, existing], []);
- expect(remoteEntries.map((entry) => entry.identity)).toEqual(
- localEntries.map((entry) => entry.identity),
- );
- expect(remoteEntries.map((entry) => entry.item)).toEqual([
- uploaded,
- existing,
- ]);
+ const uploading = homeFeedEntries([existing], [local], 200);
+ const refreshed = homeFeedEntries([uploaded, existing], [local], 200);
+ expect(refreshed).toEqual(uploading);
+ expect(refreshed.latest.map((entry) => entry.identity)).toEqual(["post:3"]);
+ expect(refreshed.history).toEqual([existing]);
+ const resolved = homeFeedEntries([uploaded, existing], [], 200);
+ expect(resolved.latest.map((entry) => entry.identity)).toEqual(["post:3"]);
+ expect(resolved.history).toEqual([existing]);
+ expect(homeFeedEntries([uploaded, existing], [local], 400)).toEqual({
+ latest: [],
+ history: [uploaded, existing],
+ });
});
-test.each([1, 3])(
- "separates a refresh with %s new posts from the previous feed",
- (count) => {
- const previous = post(2, 200);
- const newPosts = Array.from({ length: count }, (_, index) =>
- post(count + 2 - index, 300 + count - index),
- );
- expect(
- homeFeedSeparatorBefore(
- homeFeedEntries([...newPosts, previous, post(1, 100)], []),
- previous,
- ),
- ).toBe("post:2");
- },
-);
-
-test("does not separate initial loads, unchanged refreshes, or older pages", () => {
- const posts = [post(2, 200), post(1, 100)];
- expect(
- homeFeedSeparatorBefore(homeFeedEntries(posts, []), undefined),
- ).toBeUndefined();
- expect(
- homeFeedSeparatorBefore(homeFeedEntries(posts, []), posts[0]),
- ).toBeUndefined();
- expect(
- homeFeedSeparatorBefore(
- homeFeedEntries([...posts, post(0, 50)], []),
- posts[0],
- ),
- ).toBeUndefined();
-});
-
-test("keeps the boundary when the previously newest post has been deleted", () => {
- expect(
- homeFeedSeparatorBefore(
- homeFeedEntries([post(3, 300), post(1, 100)], []),
- post(2, 200),
- ),
- ).toBe("post:1");
+test("pending and failed uploads remain cards even without a previous visit", () => {
+ const pending: LocalSpaceFeedPost = {
+ caption: "Uploading",
+ frameAspectRatio: 1,
+ friendID: "self",
+ id: "upload",
+ imageUrl: "blob:preview",
+ name: "Me",
+ photoCount: 1,
+ spaceId: "self",
+ status: "pending",
+ timestampMs: 300,
+ };
+ for (const status of ["pending", "failed"] as const) {
+ const result = homeFeedEntries([], [{ ...pending, status }], undefined);
+ expect(result.latest.map((entry) => entry.identity)).toEqual([
+ "local:upload",
+ ]);
+ expect(result.history).toEqual([]);
+ }
});
-test("waits for older posts when new posts fill the first page", () => {
- const posts = [post(4, 400), post(3, 300)];
- const previous = post(2, 200);
- expect(
- homeFeedSeparatorBefore(homeFeedEntries(posts, []), previous),
- ).toBeUndefined();
- expect(
- homeFeedSeparatorBefore(
- homeFeedEntries([...posts, previous, post(1, 100)], []),
- previous,
- ),
- ).toBe("post:2");
+test("a post published in this session stays latest after the server replaces the local upload", () => {
+ const uploaded = { ...post(3, 200), spaceId: "self", friendID: "self" };
+ const local: LocalSpaceFeedPost = {
+ id: "upload",
+ post: uploaded,
+ status: "ready",
+ };
+ const latestPostIDs = new Set([uploaded.postId]);
+ const localEntries = homeFeedEntries(
+ [uploaded],
+ [local],
+ 300,
+ latestPostIDs,
+ "self",
+ );
+ const remoteEntries = homeFeedEntries(
+ [uploaded],
+ [],
+ 300,
+ latestPostIDs,
+ "self",
+ );
+ expect(localEntries.latest.map((entry) => entry.identity)).toEqual([
+ "post:3",
+ ]);
+ expect(remoteEntries.latest.map((entry) => entry.identity)).toEqual([
+ "post:3",
+ ]);
+ expect(remoteEntries.history).toEqual([]);
+ expect(homeFeedEntries([uploaded], [], 100, new Set(), "self")).toEqual({
+ latest: [],
+ history: [uploaded],
+ });
});
-test("uses post order to separate posts sharing a timestamp", () => {
- const previous = post(2, 200);
- expect(
- homeFeedSeparatorBefore(
- homeFeedEntries([post(3, 200), previous, post(1, 100)], []),
- previous,
- ),
- ).toBe("post:2");
+test("the separator follows the latest/grid boundary even when older own posts sort first", () => {
+ const own = { ...post(4, 400), spaceId: "self", friendID: "self" };
+ const sections = homeFeedEntries(
+ [own, post(3, 300), post(1, 100)],
+ [],
+ 200,
+ new Set(),
+ "self",
+ );
+ expect(sections.latest.map((entry) => entry.identity)).toEqual(["post:3"]);
+ expect(sections.history.map((item) => item.postId)).toEqual([4, 1]);
+ expect(homeFeedSeparatorBefore(sections.latest, sections.history)).toBe(
+ "post:4",
+ );
});
-test("a local upload alone does not create a new-post boundary", () => {
- const previous = post(2, 200);
+test("the separator includes own new posts and waits for older history", () => {
+ const uploaded = { ...post(4, 400), spaceId: "self", friendID: "self" };
const local: LocalSpaceFeedPost = {
id: "upload",
- post: post(4, 400),
+ post: uploaded,
status: "ready",
};
+ const latestPostIDs = new Set([uploaded.postId]);
+ const localOnly = homeFeedEntries(
+ [post(1, 100)],
+ [local],
+ 200,
+ latestPostIDs,
+ "self",
+ );
+ expect(homeFeedSeparatorBefore(localOnly.latest, localOnly.history)).toBe(
+ "post:1",
+ );
+ const confirmed = homeFeedEntries(
+ [uploaded, post(1, 100)],
+ [],
+ 200,
+ latestPostIDs,
+ "self",
+ );
+ expect(homeFeedSeparatorBefore(confirmed.latest, confirmed.history)).toBe(
+ "post:1",
+ );
+ const firstPage = homeFeedEntries([post(3, 300)], [], 200);
expect(
- homeFeedSeparatorBefore(homeFeedEntries([previous], [local]), previous),
+ homeFeedSeparatorBefore(firstPage.latest, firstPage.history),
).toBeUndefined();
+ const nextPage = homeFeedEntries([post(3, 300), post(1, 100)], [], 200);
+ expect(homeFeedSeparatorBefore(nextPage.latest, nextPage.history)).toBe(
+ "post:1",
+ );
+ const nextVisit = homeFeedEntries([post(3, 300), post(1, 100)], [], 400);
expect(
- homeFeedSeparatorBefore(
- homeFeedEntries([post(3, 300), previous], [local]),
- previous,
- ),
- ).toBe("post:2");
+ homeFeedSeparatorBefore(nextVisit.latest, nextVisit.history),
+ ).toBeUndefined();
+});
+
+test("grid posts are newest first, with post IDs breaking timestamp ties", () => {
+ const sections = homeFeedEntries(
+ [post(1, 100), post(2, 200), post(3, 200)],
+ [],
+ 400,
+ );
+ expect(sections.history.map((item) => item.postId)).toEqual([3, 2, 1]);
});
+
+test.each(["pending", "failed"] as const)(
+ "%s uploads retain their render key when the server confirms the post",
+ (status) => {
+ const pending = {
+ frameAspectRatio: 1,
+ friendID: "self",
+ id: "upload",
+ imageUrl: "blob:preview",
+ name: "Me",
+ photoCount: 1,
+ spaceId: "self",
+ status,
+ timestampMs: 300,
+ } satisfies LocalSpaceFeedPost;
+ const before = homeFeedEntries([post(1, 100)], [pending], 200);
+ expect(homeFeedSeparatorBefore(before.latest, before.history)).toBe(
+ "post:1",
+ );
+ const confirmed = homeFeedEntries(
+ [post(3, 300), post(1, 100)],
+ [{ ...pending, postId: 3 }],
+ 200,
+ );
+ expect(confirmed.latest.map((entry) => entry.identity)).toEqual([
+ "post:3",
+ ]);
+ expect(confirmed.latest[0]?.renderKey).toBe(
+ before.latest[0]?.renderKey,
+ );
+ expect(confirmed.history.map((item) => item.postId)).toEqual([1]);
+ },
+);