Skip to content

armgit / ente

Public Imported from GitHub
0

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

Restore continuous home and profile feeds

Anand Baburajan358ffd75c428
diff --git a/web/apps/space/src/components/PostGrid.tsx b/web/apps/space/src/components/PostGrid.tsx
deleted file mode 100644
index 9f0216400f..0000000000
--- a/web/apps/space/src/components/PostGrid.tsx
+++ /dev/null
@@ -1,91 +0,0 @@
-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 afd02da1af..cd6fb8752e 100644
--- a/web/apps/space/src/components/PostTile.tsx
+++ b/web/apps/space/src/components/PostTile.tsx
@@ -1,17 +1,19 @@
import { Box } from "@mui/material";
-import { SpacePostAvatar } from "components/PostAvatar";
+import { SpaceCaptionText } from "components/CaptionText";
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 { spaceProfilePostRadius } from "styles/tiles";
-import { spaceTouchTargetSize } from "styles/touch-targets";
+import {
+ minimumPostPhotoFrameAspectRatio,
+ spaceProfilePostRadius,
+} from "styles/tiles";
+import { formatSpaceDate } from "utils/display";
import { thumbHashDataURLFromBase64 } from "utils/thumbhash";
const green = "#08C225";
@@ -37,48 +39,34 @@ 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;
@@ -90,6 +78,11 @@ 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);
@@ -129,19 +122,17 @@ 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
@@ -257,17 +248,74 @@ export const SpacePostTile: React.FC<SpacePostTileProps> = ({
) : null}
{!isUnavailable && (
<>
- <SpacePostPhotosBadge
- count={photoCount}
- inset={8}
- subtle={subtlePhotosBadge}
+ <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,
+ }}
/>
+ <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 && (
@@ -287,43 +335,6 @@ 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 c89c57aec6..971dd03cec 100644
--- a/web/apps/space/src/pages/app/index.tsx
+++ b/web/apps/space/src/pages/app/index.tsx
@@ -8,8 +8,6 @@ import {
cacheCurrentSpaceFeedPage,
loadCachedSpaceFeed,
loadSpaceFeedSession,
- rememberSpaceFeedSessionPosts,
- spaceFeedSessionItems,
type SpaceFeedSession,
} from "services/feed-cache";
import { consumeSentSpaceInviteFriend, spaceInviteURL } from "services/invite";
@@ -117,7 +115,6 @@ 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);
@@ -132,12 +129,9 @@ 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(
- spaceFeedSessionItems(session, cachedFeed?.items ?? []),
- );
+ setFeedItems(cachedFeed?.items ?? []);
setFeedNextCursor(
cachedFeed?.dirty ? undefined : cachedFeed?.nextCursor,
);
@@ -157,14 +151,12 @@ 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))
@@ -175,9 +167,7 @@ const Page: React.FC = () => {
.then((feed) => {
if (isCancelled() || !loadedSpaceId || !feed) return;
- setFeedItems(
- spaceFeedSessionItems(loadedFeedSession, feed.items),
- );
+ setFeedItems(feed.items);
setFeedNextCursor(feed.nextCursor);
const refreshedPostIDs = new Set(
feed.items.map((item) => item.postId),
@@ -227,7 +217,6 @@ 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),
@@ -419,7 +408,6 @@ const Page: React.FC = () => {
try {
if (status == "friend") {
clearSpaceFriendsCache();
- const feedRequestedAtMs = Date.now();
const [requests, friends, feed] =
await Promise.all([
loadCurrentFriendRequests(actorSpaceId),
@@ -431,15 +419,8 @@ 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 07b4a7c514..45c9b09406 100644
--- a/web/apps/space/src/screens/HomeScreen.tsx
+++ b/web/apps/space/src/screens/HomeScreen.tsx
@@ -29,11 +29,9 @@ 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";
@@ -235,14 +233,10 @@ 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(
- enteringCount > 0
+ firstRetainedIndex > 0
? this.props.entries
- .slice(0, enteringCount)
+ .slice(0, firstRetainedIndex)
.filter((entry) => entry.kind == "remote")
.filter(
(entry) =>
@@ -259,18 +253,6 @@ 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();
}
@@ -734,7 +716,7 @@ const FeedPhoto: React.FC<{
scrollSnapStop: "always",
maxWidth: "100%",
minWidth: 0,
- overflow: "hidden",
+ clipPath: "inset(0)",
p: 0,
position: "relative",
width: "100%",
@@ -1404,7 +1386,7 @@ const FeedItem: React.FC<FeedItemProps> = ({
borderRadius: "inherit",
display: "flex",
height: "100%",
- overflowX: "hidden",
+ overflow: "hidden",
overscrollBehaviorX: "contain",
scrollSnapType: "x mandatory",
scrollbarWidth: "none",
@@ -1934,16 +1916,8 @@ export const HomeScreen: React.FC<HomeScreenProps> = ({
const selectedPhotoFriendID = selectedViewer?.photo.friendID;
const selectedPhotoIsOwn =
Boolean(viewerSpaceId) && selectedPhotoFriendID == viewerSpaceId;
- 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 feedEntries = homeFeedEntries(feedItems, localFeedPosts);
+ const hasFeedItems = feedEntries.length > 0;
const isEmptyFeedLoading = !hasFeedItems && isFeedLoading;
const showFeedCards = hasFeedItems;
const isInstallPromptEnabled =
@@ -2313,144 +2287,21 @@ export const HomeScreen: React.FC<HomeScreenProps> = ({
width: "100%",
}}
>
- <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>
{hasFeedItems ? (
<>
- <SpacePostGrid
- postCount={
- latestFeedEntries.length +
- gridFeedItems.length
+ <FeedMotionList
+ entries={feedEntries}
+ presentedPostIdentities={
+ feedSession?.presentedPostIdentities
+ }
+ renderEntry={(entry) =>
+ entry.kind == "local"
+ ? localFeedItemFor(entry.item)
+ : feedItemFor(
+ entry.item,
+ entry.item.postId,
+ )
}
- 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 cf1a737e79..9ad9427292 100644
--- a/web/apps/space/src/screens/ProfileScreen.tsx
+++ b/web/apps/space/src/screens/ProfileScreen.tsx
@@ -24,7 +24,6 @@ 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";
@@ -609,7 +608,7 @@ export const ProfileScreen: React.FC<ProfileScreenProps> = ({
imageUrl={imageUrl}
index={index}
isUnavailable={isUnavailable}
- item={item}
+ item={{ ...item, ...dimensionsForPost(item) }}
photoIndex={photoIndex}
loadRootMargin={postImageLoadRootMargin}
onLoadImage={() => loadPostImage(shown)}
@@ -1353,11 +1352,7 @@ export const ProfileScreen: React.FC<ProfileScreenProps> = ({
width: "calc(100% - 16px)",
}}
>
- <SpacePostGrid
- items={visiblePostItems}
- postCount={displayedPostsCount}
- renderTile={renderPostTile}
- />
+ {visiblePostItems.map(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 e6e40d4525..61066711e6 100644
--- a/web/apps/space/src/services/feed-cache.ts
+++ b/web/apps/space/src/services/feed-cache.ts
@@ -12,7 +12,6 @@ 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(),
@@ -22,7 +21,6 @@ const SpaceFeedCacheSnapshotSchema = z.object({
export interface SpaceFeedCacheSnapshot {
dirty: boolean;
items: SpacePost[];
- lastVisitedAtMs?: number;
nextCursor?: string;
spaceId: string;
syncedAtMs: number;
@@ -30,8 +28,6 @@ export interface SpaceFeedCacheSnapshot {
}
export interface SpaceFeedSession {
- newPostsSinceMs: number;
- latestPosts: SpacePost[];
presentedPostIdentities: Set<string>;
}
@@ -39,7 +35,6 @@ 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;
@@ -145,67 +140,18 @@ export const loadCachedSpaceFeed = async (
}
};
-const feedSessionForSnapshot = (
- key: string,
- cached: SpaceFeedCacheSnapshot | undefined,
-) => {
+export const loadSpaceFeedSession = async (spaceId: string) => {
+ const generation = cacheGeneration;
+ const key = await cacheKey(spaceId);
+ if (!key || generation != cacheGeneration) return undefined;
let session = feedSessions.get(key);
if (!session) {
- const newPostsSinceMs = cached?.lastVisitedAtMs ?? appOpenedAtMs;
- session = {
- newPostsSinceMs,
- latestPosts: (cached?.items ?? []).filter(
- (post) =>
- post.spaceId != cached?.spaceId &&
- post.timestampMs > newPostsSinceMs,
- ),
- presentedPostIdentities: new Set(),
- };
+ session = { presentedPostIdentities: new Set() };
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 },
@@ -221,27 +167,7 @@ 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) {
@@ -256,13 +182,11 @@ 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(),
@@ -308,15 +232,6 @@ 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) {
@@ -329,14 +244,6 @@ 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,
@@ -394,5 +301,4 @@ 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 48f517029d..ef52d2a757 100644
--- a/web/apps/space/src/utils/home-feed.ts
+++ b/web/apps/space/src/utils/home-feed.ts
@@ -13,9 +13,6 @@ export type HomeFeedEntry =
export const homeFeedEntries = (
feedItems: SpacePost[],
localFeedPosts: LocalSpaceFeedPost[],
- newPostsSinceMs: number | undefined,
- latestPostIDs?: ReadonlySet<number>,
- viewerSpaceId?: string,
) => {
const localResolvedPostIds = new Set(
localFeedPosts.map((item) =>
@@ -24,7 +21,7 @@ export const homeFeedEntries = (
: item.postId,
),
);
- const entries: HomeFeedEntry[] = [
+ return [
...localFeedPosts.map((item): HomeFeedEntry => ({
identity:
item.status == "posted" || item.status == "ready"
@@ -45,32 +42,4 @@ 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 };
};
diff --git a/web/apps/space/tests/feed-cache.test.ts b/web/apps/space/tests/feed-cache.test.ts
index 0d1962fdb5..fa1a5a44d6 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 { afterEach, beforeEach, expect, test, vi } from "vitest";
+import { beforeEach, expect, test, vi } from "vitest";
import {
cacheCurrentSpaceFeedPage,
clearSpaceFeedMemoryCache,
@@ -9,13 +9,10 @@ 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(),
@@ -49,8 +46,6 @@ const post = (postId: number, spaceId = "friend"): SpacePost => ({
viewerLiked: false,
});
-afterEach(() => vi.useRealTimers());
-
beforeEach(() => {
vi.resetAllMocks();
storage.clear();
@@ -117,17 +112,17 @@ test("restores all twenty posts and their cursor, then keeps the cache bounded w
expect(afterPosting.dirty).toBe(true);
});
-test("shrinks an existing thirty-post cache without losing the visit cutoff or skipping posts", async () => {
- await cacheCurrentSpaceFeedPage(
- "self",
- { items: [post(30)] },
- undefined,
- 100,
- );
+test("restores an existing thirty-post cache without skipping posts or retaining the visit cutoff", async () => {
+ await cacheCurrentSpaceFeedPage("self", { items: [post(30)] });
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" });
+ storage.set(key, {
+ ...snapshot,
+ items: posts,
+ nextCursor: "after-thirty",
+ lastVisitedAtMs: 100,
+ });
clearSpaceFeedMemoryCache();
const restored = (await loadCachedSpaceFeed("self"))!;
expect(restored.items.map((post) => post.postId)).toEqual(
@@ -135,8 +130,71 @@ test("shrinks an existing thirty-post cache without losing the visit cutoff or s
);
expect(restored.nextCursor).toBeUndefined();
expect(restored.dirty).toBe(true);
- expect(restored.lastVisitedAtMs).toBe(100);
- expect((await loadSpaceFeedSession("self"))?.newPostsSinceMs).toBe(100);
+ 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");
});
test("restores every photo in order and preserves shared post edits", async () => {
@@ -234,282 +292,34 @@ test("a delayed refresh cannot overwrite a publication or deletion", async () =>
).toEqual([3, 2]);
});
-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,
- );
+test("feed entrance animations stay remembered across navigation and reset on reload", async () => {
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.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,
- );
+test("feed animation sessions are isolated between accounts, spaces and servers", async () => {
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);
+ session.presentedPostIdentities.add("post:1");
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"))!;
- 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: [151, 150, 149].map((id) => ({ ...post(id), timestampMs: 150 })),
- nextCursor: "older",
- });
- await rememberSpaceFeedSessionPosts("self", [post(140)]);
-
- await cacheCurrentSpaceFeedPage("self", {
- items: [post(160), post(150)],
- nextCursor: "older",
- });
- expect(session.latestPosts.map((post) => post.postId)).toEqual([
- 160, 150, 149, 140,
- ]);
-});
-
-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"))!;
- 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(
- 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("a first-session publication stays latest until the next app opening", async () => {
- const session = (await loadSpaceFeedSession("self"))!;
- 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([]);
+ (await loadSpaceFeedSession("other"))?.presentedPostIdentities.size,
+ ).toBe(0);
vi.mocked(savedPartialLocalUser).mockReturnValue({ id: 2 });
- expect((await loadSpaceFeedSession("self"))?.latestPosts).toEqual([]);
+ expect(
+ (await loadSpaceFeedSession("self"))?.presentedPostIdentities.size,
+ ).toBe(0);
vi.mocked(savedPartialLocalUser).mockReturnValue({ id: 1 });
vi.mocked(apiOrigin).mockResolvedValue("https://other.example.com");
- expect((await loadSpaceFeedSession("self"))?.latestPosts).toEqual([]);
+ expect(
+ (await loadSpaceFeedSession("self"))?.presentedPostIdentities.size,
+ ).toBe(0);
vi.mocked(apiOrigin).mockResolvedValue("https://api.example.com");
expect(await loadSpaceFeedSession("self")).toBe(session);
});
diff --git a/web/apps/space/tests/home-feed.test.ts b/web/apps/space/tests/home-feed.test.ts
index e5bab67209..bec18b6ca7 100644
--- a/web/apps/space/tests/home-feed.test.ts
+++ b/web/apps/space/tests/home-feed.test.ts
@@ -12,109 +12,88 @@ const post = (postId: number, timestampMs: number): SpacePost => ({
viewerLiked: false,
});
-test("the first visit puts all existing posts in the grid, including later pages", () => {
+test("existing posts and later pages remain in one continuous feed", () => {
const posts = [post(3, 300), post(2, 200), post(1, 100)];
- expect(homeFeedEntries(posts, [], undefined)).toEqual({
- latest: [],
- history: posts,
- });
- expect(homeFeedEntries(posts, [], 400)).toEqual({
- latest: [],
- history: posts,
- });
+ 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);
});
-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("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 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(["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("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([
+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",
]);
- expect(result.history).toEqual([]);
- }
-});
+ 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("a post published in this session stays latest after the server replaces the local upload", () => {
- const uploaded = { ...post(3, 200), spaceId: "self", friendID: "self" };
+test("own posts stay in the same feed after the local publication is removed", () => {
+ const uploaded = { ...post(3, 300), spaceId: "self", friendID: "self" };
+ const existing = post(2, 200);
const local: LocalSpaceFeedPost = {
id: "upload",
post: uploaded,
status: "ready",
};
- const latestPostIDs = new Set([uploaded.postId]);
- const localEntries = homeFeedEntries(
- [uploaded],
- [local],
- 300,
- latestPostIDs,
- "self",
+ const localEntries = homeFeedEntries([uploaded, existing], [local]);
+ const remoteEntries = homeFeedEntries([uploaded, existing], []);
+ expect(remoteEntries.map((entry) => entry.identity)).toEqual(
+ localEntries.map((entry) => entry.identity),
);
- 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.map((entry) => entry.item)).toEqual([
+ uploaded,
+ existing,
]);
- expect(remoteEntries.history).toEqual([]);
- expect(homeFeedEntries([uploaded], [], 100, new Set(), "self")).toEqual({
- latest: [],
- history: [uploaded],
- });
});