π End-to-end encrypted cloud for everything.
Dart 2faandroidauthye2eeencryptionend-to-end-encryptionfluttergolanggoogle-photosgoogle-photos-alternativeiosopensourcephotosprivacyprivacy-toolstypescriptzero-knowledge
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.tsxnew file mode 100644index 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.tsxindex 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} /><SpacePostVideoBadgedurationMs={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.tsxindex 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.tsxindex 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 && (<Boxdiff --git a/web/apps/space/src/screens/ProfileScreen.tsx b/web/apps/space/src/screens/ProfileScreen.tsxindex 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.tsindex 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.tsindex 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.tsindex 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 wexpect(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.tsindex 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]);+ },+);