Skip to content

armgit / ente

Public Imported from GitHub
0

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

Improve Space feed loading and updates

Anand Baburajanfc35db42c4c5
diff --git a/web/apps/space/src/pages/app/friends/[spaceId].tsx b/web/apps/space/src/pages/app/friends/[spaceId].tsx
index 6d987bb92d..4cc1c40efc 100644
--- a/web/apps/space/src/pages/app/friends/[spaceId].tsx
+++ b/web/apps/space/src/pages/app/friends/[spaceId].tsx
@@ -19,6 +19,10 @@ import {
setCurrentPostLiked,
type SpaceProfilePost,
} from "services/space";
+import {
+ patchCachedSpaceFeedPost,
+ removeCachedSpaceFeedPostsBySpace,
+} from "services/spaceFeedCache";
import { useSpaceAppState } from "state/spaceAppState";
import { profilePostGroupsFromPosts } from "utils/spacePostDisplay";
import { spaceDefaultCoverImagePath } from "utils/spacePostImage";
@@ -201,6 +205,10 @@ const Page: React.FC = () => {
if (!actorSpaceId || !selectedFriendSpaceId) return;
await removeCurrentSpaceFriend(actorSpaceId, selectedFriendSpaceId);
+ void removeCachedSpaceFeedPostsBySpace(
+ actorSpaceId,
+ selectedFriendSpaceId,
+ );
}, [profile?.spaceId, selectedFriendSpaceId]);
const finishUnfriend = React.useCallback(() => {
@@ -296,9 +304,12 @@ const Page: React.FC = () => {
onReplyToPost={(postSpaceId, postId, text) =>
replyToCurrentPost(actorSpaceId, postSpaceId, postId, text)
}
- onSetPostLiked={(postId, liked) =>
- setCurrentPostLiked(actorSpaceId, postId, liked)
- }
+ onSetPostLiked={async (postId, liked) => {
+ await setCurrentPostLiked(actorSpaceId, postId, liked);
+ void patchCachedSpaceFeedPost(actorSpaceId, postId, {
+ viewerLiked: liked,
+ });
+ }}
onUnfriend={selectedFriendSpaceId ? unfriend : undefined}
onUnfriendComplete={
selectedFriendSpaceId ? finishUnfriend : undefined
diff --git a/web/apps/space/src/pages/app/friends/index.tsx b/web/apps/space/src/pages/app/friends/index.tsx
index cf40588dff..54221f2523 100644
--- a/web/apps/space/src/pages/app/friends/index.tsx
+++ b/web/apps/space/src/pages/app/friends/index.tsx
@@ -14,6 +14,10 @@ import {
removeCurrentSpaceFriend,
type SpaceFriendRequest,
} from "services/space";
+import {
+ invalidateCachedSpaceFeed,
+ removeCachedSpaceFeedPostsBySpace,
+} from "services/spaceFeedCache";
import { spaceInviteURL } from "services/spaceInvite";
import { useSpaceAppState } from "state/spaceAppState";
import { spaceRoutes } from "utils/spaceRoutes";
@@ -121,6 +125,7 @@ const Page: React.FC = () => {
setShowFriendRequestCanceledToast(true);
return;
}
+ void invalidateCachedSpaceFeed(actorSpaceId);
const friends = await loadCurrentSpaceFriends(actorSpaceId);
setFriendRequests((currentRequests) =>
currentRequests.filter(
@@ -178,6 +183,10 @@ const Page: React.FC = () => {
actorSpaceId,
friend.spaceId,
);
+ void removeCachedSpaceFeedPostsBySpace(
+ actorSpaceId,
+ friend.spaceId,
+ );
setFriends((currentFriends) =>
currentFriends.filter(
(candidate) => candidate.id != friendID,
diff --git a/web/apps/space/src/pages/app/index.tsx b/web/apps/space/src/pages/app/index.tsx
index 822efb858a..cbd72df1fe 100644
--- a/web/apps/space/src/pages/app/index.tsx
+++ b/web/apps/space/src/pages/app/index.tsx
@@ -16,6 +16,13 @@ import {
updateCurrentPostCaption,
type SpacePost,
} from "services/space";
+import {
+ cacheCurrentSpaceFeedPage,
+ loadCachedSpaceFeed,
+ patchCachedSpaceFeedPost,
+ prependCachedSpaceFeedPost,
+ removeCachedSpaceFeedPost,
+} from "services/spaceFeedCache";
import {
consumeSentSpaceInviteFriend,
spaceInviteURL,
@@ -112,20 +119,45 @@ const Page: React.FC = () => {
setIsFeedLoadingMore(false);
setIsFriendsLoading(true);
void loadExistingSpaceId()
- .then((nextSpaceId) => {
+ .then(async (nextSpaceId) => {
if (cancelled) return undefined;
loadedSpaceId = nextSpaceId;
setSpaceId(nextSpaceId);
- return nextSpaceId
- ? loadCurrentFeedPage(nextSpaceId)
- : undefined;
+ if (!nextSpaceId) return undefined;
+
+ let freshFeedApplied = false;
+ const cachedFeedLoad = loadCachedSpaceFeed(nextSpaceId);
+ const freshFeedLoad = loadCurrentFeedPage(nextSpaceId);
+ void cachedFeedLoad.then((cachedFeed) => {
+ if (cancelled || freshFeedApplied || !cachedFeed) return;
+
+ setFeedItems(cachedFeed.items);
+ setFeedNextCursor(
+ cachedFeed.dirty ? undefined : cachedFeed.nextCursor,
+ );
+ });
+
+ const feed = await freshFeedLoad;
+ freshFeedApplied = true;
+ return feed;
})
.then((feed) => {
- if (cancelled || !feed) return;
+ if (cancelled || !loadedSpaceId || !feed) return;
setFeedItems(feed.items);
setFeedNextCursor(feed.nextCursor);
+ void cacheCurrentSpaceFeedPage(loadedSpaceId, feed);
+ const refreshedPostIDs = new Set(
+ feed.items.map((item) => item.postId),
+ );
+ setLocalFeedPosts((currentPosts) =>
+ currentPosts.filter(
+ (item) =>
+ item.status != "ready" ||
+ !refreshedPostIDs.has(item.post.postId),
+ ),
+ );
})
.catch((error: unknown) =>
console.error("Failed to load space feed", error),
@@ -168,7 +200,7 @@ const Page: React.FC = () => {
return () => {
cancelled = true;
};
- }, [setFriends, setSkipNextHomeFeedSkeleton]);
+ }, [setFriends, setLocalFeedPosts, setSkipNextHomeFeedSkeleton]);
const loadMoreFeedItems = React.useCallback(async () => {
if (!spaceId || !feedNextCursor || isFeedLoadingMore) return;
@@ -202,6 +234,9 @@ const Page: React.FC = () => {
if (!spaceId) throw new Error("Missing space.");
await setCurrentPostLiked(spaceId, postId, liked);
+ void patchCachedSpaceFeedPost(spaceId, postId, {
+ viewerLiked: liked,
+ });
setFeedItems((currentItems) =>
currentItems.map((item) =>
item.postId == postId
@@ -240,6 +275,7 @@ const Page: React.FC = () => {
isFriendsLoading={isFriendsLoading}
localFeedPosts={localFeedPosts}
profile={profile}
+ viewerSpaceId={spaceId ?? profile?.spaceId}
showInstallPrompt={
profileLoadStatus == "ready" &&
Boolean(profile) &&
@@ -309,6 +345,10 @@ const Page: React.FC = () => {
localPostId,
post,
);
+ void prependCachedSpaceFeedPost(
+ spaceId,
+ post,
+ );
if (isFirstPost) {
inviteFriendsToastTimerRef.current =
window.setTimeout(() => {
@@ -334,6 +374,7 @@ const Page: React.FC = () => {
const spaceId = profile?.spaceId;
if (!spaceId) throw new Error("Missing space.");
await deleteCurrentPost(spaceId, postId);
+ void removeCachedSpaceFeedPost(spaceId, postId);
setLocalFeedPosts((currentPosts) =>
currentPosts.filter(
(item) =>
@@ -352,6 +393,9 @@ const Page: React.FC = () => {
await updateCurrentPostCaption(spaceId, postId, caption);
const normalizedCaption = caption.trim() || undefined;
+ void patchCachedSpaceFeedPost(spaceId, postId, {
+ caption: normalizedCaption,
+ });
setLocalFeedPosts((currentPosts) =>
currentPosts.map((item) =>
(item.status == "posted" ||
diff --git a/web/apps/space/src/pages/app/posts/[spaceId]/[postId].tsx b/web/apps/space/src/pages/app/posts/[spaceId]/[postId].tsx
index 2530112455..4630c7bfb3 100644
--- a/web/apps/space/src/pages/app/posts/[spaceId]/[postId].tsx
+++ b/web/apps/space/src/pages/app/posts/[spaceId]/[postId].tsx
@@ -8,6 +8,7 @@ import {
setCurrentPostLiked,
type SpacePost,
} from "services/space";
+import { patchCachedSpaceFeedPost } from "services/spaceFeedCache";
import { useSpaceAppState } from "state/spaceAppState";
import { spaceRoutes } from "utils/spaceRoutes";
import { useSpaceRouter } from "utils/spaceRouteTransitions";
@@ -174,9 +175,12 @@ const Page: React.FC = () => {
text,
)
}
- onSetPostLiked={(nextPostId, liked) =>
- setCurrentPostLiked(actorSpaceId, nextPostId, liked)
- }
+ onSetPostLiked={async (nextPostId, liked) => {
+ await setCurrentPostLiked(actorSpaceId, nextPostId, liked);
+ void patchCachedSpaceFeedPost(actorSpaceId, nextPostId, {
+ viewerLiked: liked,
+ });
+ }}
/>
</>
);
diff --git a/web/apps/space/src/pages/app/profile.tsx b/web/apps/space/src/pages/app/profile.tsx
index 40bb3f482f..11e68ac345 100644
--- a/web/apps/space/src/pages/app/profile.tsx
+++ b/web/apps/space/src/pages/app/profile.tsx
@@ -13,6 +13,11 @@ import {
updateCurrentPostCaption,
type SpaceProfilePost,
} from "services/space";
+import {
+ patchCachedSpaceFeedPost,
+ prependCachedSpaceFeedPost,
+ removeCachedSpaceFeedPost,
+} from "services/spaceFeedCache";
import { spaceInviteURL } from "services/spaceInvite";
import { useSpaceAppState } from "state/spaceAppState";
import {
@@ -175,6 +180,7 @@ const Page: React.FC = () => {
localPostId,
post,
);
+ void prependCachedSpaceFeedPost(spaceId, post);
} catch (error) {
failLocalFeedPost(
setLocalFeedPosts,
@@ -191,6 +197,7 @@ const Page: React.FC = () => {
const spaceId = profile.spaceId;
if (!spaceId) throw new Error("Missing space.");
await deleteCurrentPost(spaceId, postId);
+ void removeCachedSpaceFeedPost(spaceId, postId);
setLocalFeedPosts((currentPosts) =>
currentPosts.filter(
(item) =>
@@ -209,6 +216,9 @@ const Page: React.FC = () => {
await updateCurrentPostCaption(spaceId, postId, caption);
const normalizedCaption = caption.trim() || undefined;
+ void patchCachedSpaceFeedPost(spaceId, postId, {
+ caption: normalizedCaption,
+ });
setLocalFeedPosts((currentPosts) =>
currentPosts.map((item) =>
(item.status == "posted" ||
@@ -241,9 +251,12 @@ const Page: React.FC = () => {
}
onOpenSettings={() => void router.push(spaceRoutes.settings)}
onLoadPostImage={loadCurrentSpacePostAssetURL}
- onSetPostLiked={(postId, liked) =>
- setCurrentPostLiked(actorSpaceId, postId, liked)
- }
+ onSetPostLiked={async (postId, liked) => {
+ await setCurrentPostLiked(actorSpaceId, postId, liked);
+ void patchCachedSpaceFeedPost(actorSpaceId, postId, {
+ viewerLiked: liked,
+ });
+ }}
profileLink={spaceInviteURL({
spaceUsername: profile.username,
})}
diff --git a/web/apps/space/src/screens/HomeScreen.tsx b/web/apps/space/src/screens/HomeScreen.tsx
index 6806e62995..36f1485231 100644
--- a/web/apps/space/src/screens/HomeScreen.tsx
+++ b/web/apps/space/src/screens/HomeScreen.tsx
@@ -72,6 +72,9 @@ const feedHorizontalPadding = "16px";
const minimumFeedPhotoFrameAspectRatio = 3 / 4;
const feedMediaLoadRootMargin = "640px 0px";
const feedLoadMoreRootMargin = "0px 0px 160px 0px";
+const feedRowEnterDurationMs = 460;
+const feedRowEnterStaggerMs = 35;
+const feedRowEnterTiming = "cubic-bezier(0.2, 0.8, 0.2, 1)";
const avatarFadeSx = {
"@keyframes spaceAvatarFade": { from: { opacity: 0 }, to: { opacity: 1 } },
animation: "spaceAvatarFade 320ms cubic-bezier(0.22, 1, 0.36, 1) both",
@@ -144,6 +147,7 @@ interface HomeScreenProps {
onUpdatePostCaption?: (postId: number, caption: string) => Promise<void>;
profileLink?: string;
profile: SetupProfile | null;
+ viewerSpaceId?: string;
}
interface FeedPhotoDimensions {
@@ -181,6 +185,205 @@ interface DraftSpacePostImage {
width?: number;
}
+type HomeFeedEntry =
+ | {
+ identity: string;
+ item: LocalSpaceFeedPost;
+ kind: "local";
+ renderKey: string;
+ }
+ | { identity: string; item: SpacePost; kind: "remote"; renderKey: string };
+
+interface FeedLayoutSnapshot {
+ enteringKeys: Set<string>;
+ previousTops: Map<string, number>;
+}
+
+interface FeedMotionListProps {
+ entries: HomeFeedEntry[];
+ renderEntry: (entry: HomeFeedEntry) => React.ReactNode;
+}
+
+class FeedMotionList extends React.Component<FeedMotionListProps> {
+ private animations = new Map<string, Animation>();
+ private identityKeys = new Map<string, string>();
+ private rowElements = new Map<string, HTMLDivElement>();
+ private rowRefs = new Map<
+ string,
+ (element: HTMLDivElement | null) => void
+ >();
+ private sourceKeys = new Map<string, string>();
+
+ private stableKeyFor = (entry: HomeFeedEntry) => {
+ const stableKey =
+ this.identityKeys.get(entry.identity) ??
+ this.sourceKeys.get(entry.renderKey) ??
+ entry.renderKey;
+ this.identityKeys.set(entry.identity, stableKey);
+ this.sourceKeys.set(entry.renderKey, stableKey);
+ return stableKey;
+ };
+
+ private rowRefFor = (key: string) => {
+ let rowRef = this.rowRefs.get(key);
+ if (!rowRef) {
+ rowRef = (element) => {
+ if (element) this.rowElements.set(key, element);
+ else this.rowElements.delete(key);
+ };
+ this.rowRefs.set(key, rowRef);
+ }
+ return rowRef;
+ };
+
+ private cancelAnimations = () => {
+ this.animations.forEach((animation) => animation.cancel());
+ this.animations.clear();
+ this.rowElements.forEach((element) => {
+ element.style.zIndex = "";
+ });
+ };
+
+ getSnapshotBeforeUpdate(
+ previousProps: FeedMotionListProps,
+ ): FeedLayoutSnapshot | null {
+ const previousIdentityOrder = previousProps.entries.map(
+ (entry) => entry.identity,
+ );
+ const identityOrder = this.props.entries.map((entry) => entry.identity);
+ if (
+ previousIdentityOrder.length == identityOrder.length &&
+ previousIdentityOrder.every(
+ (identity, index) => identity == identityOrder[index],
+ )
+ )
+ return null;
+
+ const previousIdentities = new Set(previousIdentityOrder);
+ const addedEntries = this.props.entries.filter(
+ (entry) => !previousIdentities.has(entry.identity),
+ );
+ if (
+ previousProps.entries.length == 0 ||
+ addedEntries.some((entry) => entry.kind == "local")
+ )
+ return null;
+
+ const firstRetainedIndex = this.props.entries.findIndex((entry) =>
+ previousIdentities.has(entry.identity),
+ );
+ const enteringKeys = new Set(
+ firstRetainedIndex > 0
+ ? this.props.entries
+ .slice(0, firstRetainedIndex)
+ .filter((entry) => entry.kind == "remote")
+ .map(this.stableKeyFor)
+ : [],
+ );
+ const previousTops = new Map<string, number>();
+ this.rowElements.forEach((element, key) => {
+ previousTops.set(key, element.getBoundingClientRect().top);
+ });
+ return { enteringKeys, previousTops };
+ }
+
+ componentDidUpdate(
+ _previousProps: FeedMotionListProps,
+ _previousState: unknown,
+ snapshot: FeedLayoutSnapshot | null,
+ ) {
+ if (
+ !snapshot ||
+ window.matchMedia("(prefers-reduced-motion: reduce)").matches
+ )
+ return;
+
+ this.cancelAnimations();
+ let enteringIndex = 0;
+ for (const entry of this.props.entries) {
+ const key = this.stableKeyFor(entry);
+ const element = this.rowElements.get(key);
+ if (!element) continue;
+
+ let animation: Animation | undefined;
+ if (snapshot.enteringKeys.has(key)) {
+ const delay = enteringIndex * feedRowEnterStaggerMs;
+ element.style.zIndex = String(3 - enteringIndex++);
+ animation = element.animate(
+ [
+ {
+ clipPath: "inset(0 0 100% 0)",
+ transform: "translate3d(0, -20px, 0)",
+ },
+ {
+ clipPath: "inset(0 0 0% 0)",
+ transform: "translate3d(0, 0, 0)",
+ },
+ ],
+ {
+ delay,
+ duration: feedRowEnterDurationMs,
+ easing: feedRowEnterTiming,
+ fill: "both",
+ },
+ );
+ } else {
+ const previousTop = snapshot.previousTops.get(key);
+ if (previousTop == undefined) continue;
+ const offsetY =
+ previousTop - element.getBoundingClientRect().top;
+ if (!offsetY) continue;
+ animation = element.animate(
+ [
+ { transform: `translate3d(0, ${offsetY}px, 0)` },
+ { transform: "translate3d(0, 0, 0)" },
+ ],
+ {
+ duration: feedRowEnterDurationMs,
+ easing: feedRowEnterTiming,
+ fill: "both",
+ },
+ );
+ }
+
+ this.animations.set(key, animation);
+ void animation.finished.then(
+ () => {
+ if (this.animations.get(key) != animation) return;
+ animation.cancel();
+ this.animations.delete(key);
+ element.style.zIndex = "";
+ },
+ () => undefined,
+ );
+ }
+ }
+
+ componentWillUnmount() {
+ this.cancelAnimations();
+ }
+
+ render() {
+ return this.props.entries.map((entry) => {
+ const key = this.stableKeyFor(entry);
+ return (
+ <Box
+ key={key}
+ ref={this.rowRefFor(key)}
+ sx={{
+ minWidth: 0,
+ pb: "24px",
+ position: "relative",
+ width: "100%",
+ }}
+ >
+ {this.props.renderEntry(entry)}
+ </Box>
+ );
+ });
+ }
+}
+
type FeedTimestampStatus = "failed" | "post-limit" | "posted" | "posting";
interface FeedItemProps {
@@ -1306,6 +1509,7 @@ export const HomeScreen: React.FC<HomeScreenProps> = ({
onUpdatePostCaption,
profile,
profileLink,
+ viewerSpaceId,
}) => {
const [selectedViewer, setSelectedViewer] =
useState<SelectedHomeViewer | null>(null);
@@ -1332,22 +1536,44 @@ export const HomeScreen: React.FC<HomeScreenProps> = ({
const feedImageLoadsInFlightRef = React.useRef<
Map<string, Promise<string | undefined>>
>(new Map());
- const profileSpaceId = profile?.spaceId;
const isPostPhotoButtonDisabled =
- isPostPhotoOpening || !profileSpaceId || !onCreatePost;
+ isPostPhotoOpening || !viewerSpaceId || !onCreatePost;
const selectedPhotoFriendID = selectedViewer?.photo.friendID;
const selectedPhotoIsOwn =
- Boolean(profileSpaceId) && selectedPhotoFriendID == profileSpaceId;
- const localResolvedPostIds = new Set(
- localFeedPosts
- .filter((item) => item.status == "posted" || item.status == "ready")
- .map((item) => item.post.postId),
- );
- const remoteFeedItems = feedItems.filter(
- (item) => !localResolvedPostIds.has(item.postId),
- );
- const hasFeedItems =
- localFeedPosts.length > 0 || remoteFeedItems.length > 0;
+ Boolean(viewerSpaceId) && selectedPhotoFriendID == viewerSpaceId;
+ const desiredFeedEntries = React.useMemo<HomeFeedEntry[]>(() => {
+ const localResolvedPostIds = new Set(
+ localFeedPosts
+ .filter(
+ (item) => item.status == "posted" || item.status == "ready",
+ )
+ .map((item) => item.post.postId),
+ );
+ return [
+ ...localFeedPosts.map(
+ (item): HomeFeedEntry => ({
+ identity:
+ item.status == "posted" || item.status == "ready"
+ ? `post:${item.post.postId}`
+ : `local:${item.id}`,
+ item,
+ kind: "local",
+ renderKey: `local:${item.id}`,
+ }),
+ ),
+ ...feedItems
+ .filter((item) => !localResolvedPostIds.has(item.postId))
+ .map(
+ (item): HomeFeedEntry => ({
+ identity: `post:${item.postId}`,
+ item,
+ kind: "remote",
+ renderKey: `post:${item.postId}`,
+ }),
+ ),
+ ];
+ }, [feedItems, localFeedPosts]);
+ const hasFeedItems = desiredFeedEntries.length > 0;
const isEmptyFeedLoading = !hasFeedItems && isFeedLoading;
const showFeedCards = hasFeedItems;
const isInstallPromptEnabled =
@@ -1382,7 +1608,7 @@ export const HomeScreen: React.FC<HomeScreenProps> = ({
focusReplyOnOpen = false,
) => {
const isOwnPost =
- Boolean(profileSpaceId) && photo.friendID == profileSpaceId;
+ Boolean(viewerSpaceId) && photo.friendID == viewerSpaceId;
setSelectedViewer({
focusReplyOnOpen: isOwnPost ? false : focusReplyOnOpen,
photo,
@@ -1514,7 +1740,7 @@ export const HomeScreen: React.FC<HomeScreenProps> = ({
imageUrl={imageUrl}
isAvatarPending={isAvatarPending}
isOwnPost={
- Boolean(profileSpaceId) && item.spaceId == profileSpaceId
+ Boolean(viewerSpaceId) && item.spaceId == viewerSpaceId
}
name={item.name}
onLoadAvatar={
@@ -1779,7 +2005,7 @@ export const HomeScreen: React.FC<HomeScreenProps> = ({
}}
sx={{
alignItems: "center",
- bgcolor: homeBackground,
+ background: "transparent",
boxSizing: "border-box",
display: "grid",
gap: "12px",
@@ -1798,6 +2024,24 @@ export const HomeScreen: React.FC<HomeScreenProps> = ({
transition: "transform 180ms ease",
width: "100%",
zIndex: 4,
+ "&::before": {
+ WebkitBackdropFilter: "blur(4px)",
+ WebkitMaskImage:
+ "linear-gradient(to bottom, #000 0%, transparent 100%)",
+ backdropFilter: "blur(4px)",
+ background:
+ "linear-gradient(to bottom, rgba(245, 245, 247, 0.8), transparent)",
+ content: '""',
+ height: "calc(100% + 28px)",
+ left: 0,
+ maskImage:
+ "linear-gradient(to bottom, #000 0%, transparent 100%)",
+ pointerEvents: "none",
+ position: "absolute",
+ right: 0,
+ top: 0,
+ zIndex: -1,
+ },
"@media (min-width: 600px)": { maxWidth: 390 },
"@media (prefers-reduced-motion: reduce)": {
transition: "none",
@@ -1991,7 +2235,7 @@ export const HomeScreen: React.FC<HomeScreenProps> = ({
boxSizing: "border-box",
display: "flex",
flexDirection: "column",
- gap: showFeedCards ? "24px" : 0,
+ gap: 0,
justifyContent: showFeedCards ? "flex-start" : "center",
minHeight: "calc(100svh - 64px)",
minWidth: 0,
@@ -2005,10 +2249,17 @@ export const HomeScreen: React.FC<HomeScreenProps> = ({
>
{hasFeedItems ? (
<>
- {localFeedPosts.map(localFeedItemFor)}
- {remoteFeedItems.map((item) =>
- feedItemFor(item, item.postId),
- )}
+ <FeedMotionList
+ entries={desiredFeedEntries}
+ renderEntry={(entry) =>
+ entry.kind == "local"
+ ? localFeedItemFor(entry.item)
+ : feedItemFor(
+ entry.item,
+ entry.item.postId,
+ )
+ }
+ />
{hasMoreFeedItems && onLoadMoreFeedItems && (
<Box
ref={feedLoadMoreRef}
@@ -2207,7 +2458,7 @@ export const HomeScreen: React.FC<HomeScreenProps> = ({
onSwipeLeft={closeSelectedPhoto}
onReplyToPost={
!selectedPhotoIsOwn &&
- selectedViewer.photo.friendID != profileSpaceId
+ selectedViewer.photo.friendID != viewerSpaceId
? onReplyToPost
: undefined
}
diff --git a/web/apps/space/src/services/spaceFeedCache.ts b/web/apps/space/src/services/spaceFeedCache.ts
new file mode 100644
index 0000000000..86fa6d800d
--- /dev/null
+++ b/web/apps/space/src/services/spaceFeedCache.ts
@@ -0,0 +1,276 @@
+import { savedPartialLocalUser } from "ente-accounts-rs/services/accounts-db";
+import { getKV, removeKV, setKV } from "ente-base/kv";
+import { apiOrigin } from "ente-base/origins";
+import type { SpacePost, SpacePostPage } from "services/space";
+import { z } from "zod";
+
+const spaceFeedCacheVersion = 1;
+const spaceFeedCacheSize = 10;
+
+const CachedSpacePostAsset = z.object({
+ encryptedPostKey: z.string(),
+ keyVersion: z.number(),
+ mediaType: z.string().optional(),
+ objectKey: z.string(),
+ postId: z.number(),
+ spaceId: z.string(),
+});
+
+const CachedSpacePost = z.object({
+ avatarKeyVersion: z.number().optional(),
+ avatarObjectID: z.string().optional(),
+ avatarSize: z.number().optional(),
+ avatarUpdatedAt: z.string().optional(),
+ caption: z.string().optional(),
+ friendID: z.string(),
+ height: z.number().optional(),
+ imageAsset: CachedSpacePostAsset.optional(),
+ name: z.string(),
+ postId: z.number(),
+ spaceId: z.string(),
+ thumbHash: z.string().optional(),
+ timestampMs: z.number(),
+ viewerLiked: z.boolean(),
+ width: z.number().optional(),
+});
+
+const SpaceFeedCacheSnapshotSchema = z.object({
+ dirty: z.boolean(),
+ items: CachedSpacePost.array().max(spaceFeedCacheSize),
+ nextCursor: z.string().optional(),
+ spaceId: z.string(),
+ syncedAtMs: z.number(),
+ version: z.literal(spaceFeedCacheVersion),
+});
+
+export interface SpaceFeedCacheSnapshot {
+ dirty: boolean;
+ items: SpacePost[];
+ nextCursor?: string;
+ spaceId: string;
+ syncedAtMs: number;
+ version: typeof spaceFeedCacheVersion;
+}
+
+const memoryCache = new Map<string, SpaceFeedCacheSnapshot | undefined>();
+const cacheOperations = new Map<string, Promise<void>>();
+let cacheGeneration = 0;
+
+const cacheKey = async (spaceId: string) => {
+ const userID = savedPartialLocalUser()?.id;
+ if (!userID || !spaceId.trim()) return undefined;
+ try {
+ return [
+ "space-feed",
+ `v${spaceFeedCacheVersion}`,
+ await apiOrigin(),
+ userID,
+ spaceId,
+ ].join(":");
+ } catch (error) {
+ console.warn("Failed to resolve cached Space feed", error);
+ return undefined;
+ }
+};
+
+const clonePost = (post: SpacePost): SpacePost => ({
+ ...post,
+ imageAsset: post.imageAsset ? { ...post.imageAsset } : undefined,
+});
+
+const cloneSnapshot = (
+ snapshot: SpaceFeedCacheSnapshot,
+): SpaceFeedCacheSnapshot => ({
+ ...snapshot,
+ items: snapshot.items.map(clonePost),
+});
+
+const cacheablePost = (post: SpacePost): SpacePost => {
+ const cached = clonePost(post);
+ delete cached.avatarUrl;
+ delete cached.imageUrl;
+ return cached;
+};
+
+const normalizedSnapshot = (
+ snapshot: SpaceFeedCacheSnapshot,
+): SpaceFeedCacheSnapshot => ({
+ ...snapshot,
+ items: snapshot.items.slice(0, spaceFeedCacheSize).map(cacheablePost),
+ nextCursor: snapshot.nextCursor || undefined,
+ version: spaceFeedCacheVersion,
+});
+
+const enqueueCacheOperation = async (
+ key: string,
+ operation: () => Promise<void>,
+) => {
+ const previous = cacheOperations.get(key) ?? Promise.resolve();
+ const next = previous
+ .catch(() => undefined)
+ .then(operation)
+ .catch((error: unknown) => {
+ console.warn("Failed to update cached Space feed", error);
+ });
+ cacheOperations.set(key, next);
+ await next;
+ if (cacheOperations.get(key) == next) cacheOperations.delete(key);
+};
+
+export const loadCachedSpaceFeed = async (
+ spaceId: string,
+): Promise<SpaceFeedCacheSnapshot | undefined> => {
+ const generation = cacheGeneration;
+ const key = await cacheKey(spaceId);
+ if (!key || generation != cacheGeneration) return undefined;
+
+ await cacheOperations.get(key);
+ if (generation != cacheGeneration) return undefined;
+ if (memoryCache.has(key)) {
+ const cached = memoryCache.get(key);
+ return cached ? cloneSnapshot(cached) : undefined;
+ }
+
+ try {
+ const parsed = SpaceFeedCacheSnapshotSchema.safeParse(await getKV(key));
+ if (generation != cacheGeneration) return undefined;
+ if (!parsed.success || parsed.data.spaceId != spaceId) {
+ memoryCache.set(key, undefined);
+ if (!parsed.success) await removeKV(key);
+ return undefined;
+ }
+
+ const snapshot = normalizedSnapshot(parsed.data);
+ memoryCache.set(key, snapshot);
+ return cloneSnapshot(snapshot);
+ } catch (error) {
+ console.warn("Failed to load cached Space feed", error);
+ return undefined;
+ }
+};
+
+const writeCachedSpaceFeed = async (
+ snapshot: SpaceFeedCacheSnapshot,
+): Promise<void> => {
+ const generation = cacheGeneration;
+ const key = await cacheKey(snapshot.spaceId);
+ if (!key || generation != cacheGeneration) return;
+ const normalized = normalizedSnapshot(snapshot);
+
+ await enqueueCacheOperation(key, async () => {
+ if (generation != cacheGeneration) return;
+ memoryCache.set(key, normalized);
+ await setKV(key, normalized);
+ if (generation != cacheGeneration) {
+ memoryCache.delete(key);
+ await removeKV(key);
+ }
+ });
+};
+
+export const cacheCurrentSpaceFeedPage = async (
+ spaceId: string,
+ page: SpacePostPage,
+) =>
+ writeCachedSpaceFeed({
+ dirty: false,
+ items: page.items,
+ nextCursor: page.nextCursor,
+ spaceId,
+ syncedAtMs: Date.now(),
+ version: spaceFeedCacheVersion,
+ });
+
+const updateCachedSpaceFeed = async (
+ spaceId: string,
+ update: (snapshot: SpaceFeedCacheSnapshot) => SpaceFeedCacheSnapshot,
+) => {
+ const generation = cacheGeneration;
+ const key = await cacheKey(spaceId);
+ if (!key || generation != cacheGeneration) return;
+
+ await enqueueCacheOperation(key, async () => {
+ if (generation != cacheGeneration) return;
+ let snapshot = memoryCache.get(key);
+ if (!memoryCache.has(key)) {
+ const parsed = SpaceFeedCacheSnapshotSchema.safeParse(
+ await getKV(key),
+ );
+ snapshot =
+ parsed.success && parsed.data.spaceId == spaceId
+ ? normalizedSnapshot(parsed.data)
+ : undefined;
+ }
+ if (!snapshot) return;
+
+ const nextSnapshot = normalizedSnapshot(
+ update(cloneSnapshot(snapshot)),
+ );
+ if (generation != cacheGeneration) return;
+ memoryCache.set(key, nextSnapshot);
+ await setKV(key, nextSnapshot);
+ if (generation != cacheGeneration) {
+ memoryCache.delete(key);
+ await removeKV(key);
+ }
+ });
+};
+
+const descendingPostOrder = (a: SpacePost, b: SpacePost) =>
+ b.timestampMs - a.timestampMs || b.postId - a.postId;
+
+export const prependCachedSpaceFeedPost = (spaceId: string, post: SpacePost) =>
+ updateCachedSpaceFeed(spaceId, (snapshot) => ({
+ ...snapshot,
+ dirty: true,
+ items: [
+ post,
+ ...snapshot.items.filter((item) => item.postId != post.postId),
+ ]
+ .sort(descendingPostOrder)
+ .slice(0, spaceFeedCacheSize),
+ nextCursor: undefined,
+ }));
+
+export const removeCachedSpaceFeedPost = (spaceId: string, postId: number) =>
+ updateCachedSpaceFeed(spaceId, (snapshot) => ({
+ ...snapshot,
+ dirty: true,
+ items: snapshot.items.filter((item) => item.postId != postId),
+ nextCursor: undefined,
+ }));
+
+export const removeCachedSpaceFeedPostsBySpace = (
+ viewerSpaceId: string,
+ removedSpaceId: string,
+) =>
+ updateCachedSpaceFeed(viewerSpaceId, (snapshot) => ({
+ ...snapshot,
+ dirty: true,
+ items: snapshot.items.filter((item) => item.spaceId != removedSpaceId),
+ nextCursor: undefined,
+ }));
+
+export const patchCachedSpaceFeedPost = (
+ spaceId: string,
+ postId: number,
+ patch: Partial<Pick<SpacePost, "caption" | "viewerLiked">>,
+) =>
+ updateCachedSpaceFeed(spaceId, (snapshot) => ({
+ ...snapshot,
+ items: snapshot.items.map((item) =>
+ item.postId == postId ? { ...item, ...patch } : item,
+ ),
+ }));
+
+export const invalidateCachedSpaceFeed = (spaceId: string) =>
+ updateCachedSpaceFeed(spaceId, (snapshot) => ({
+ ...snapshot,
+ dirty: true,
+ nextCursor: undefined,
+ }));
+
+export const clearSpaceFeedMemoryCache = () => {
+ cacheGeneration += 1;
+ memoryCache.clear();
+};
diff --git a/web/apps/space/src/state/SpaceAppStateProvider.tsx b/web/apps/space/src/state/SpaceAppStateProvider.tsx
index 45a72d7f1d..cb3e3c1ca3 100644
--- a/web/apps/space/src/state/SpaceAppStateProvider.tsx
+++ b/web/apps/space/src/state/SpaceAppStateProvider.tsx
@@ -11,6 +11,7 @@ import {
clearSpaceFriendsCache,
clearSpaceMediaURLCache,
} from "services/space";
+import { clearSpaceFeedMemoryCache } from "services/spaceFeedCache";
import type { PendingSpacePasskeyVerification } from "services/spacePasskeyVerification";
import { logoutRevokedSpaceSession } from "services/spacePersistentSession";
import {
@@ -222,6 +223,7 @@ export const SpaceAppStateProvider: React.FC<React.PropsWithChildren> = ({
profileLoadGenerationRef.current += 1;
clearCurrentSpaceContext();
clearSpaceFriendsCache();
+ clearSpaceFeedMemoryCache();
clearSpaceMediaURLCache();
applyProfile(null);
setProfileLoadError(undefined);