Skip to content

armgit / ente

Public Imported from GitHub
0

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

Improve Space home posts

Anand Baburajan05160f5c2827
diff --git a/rust/bindings/wasm/space/src/space.rs b/rust/bindings/wasm/space/src/space.rs
index 6588a03b04..af52f6d47c 100644
--- a/rust/bindings/wasm/space/src/space.rs
+++ b/rust/bindings/wasm/space/src/space.rs
@@ -150,6 +150,14 @@ struct PostPageJs {
next_cursor: String,
}
+#[derive(Serialize)]
+#[serde(rename_all = "camelCase")]
+struct HomePostPageJs {
+ items: Vec<PostJs>,
+ next_cursor: String,
+ sync_cursor: String,
+}
+
#[derive(Serialize)]
#[serde(rename_all = "camelCase")]
struct MessageJs {
@@ -449,6 +457,26 @@ async fn account_post_page_to_js(
})
}
+async fn account_home_post_page_to_js(
+ ctx: &AccountSpaceCtx,
+ page: ente_space::HomePostPage,
+) -> Result<HomePostPageJs, Error> {
+ let sync_cursor = page.sync_cursor;
+ let page = account_post_page_to_js(
+ ctx,
+ ente_space::PostPage {
+ items: page.items,
+ next_cursor: page.next_cursor,
+ },
+ )
+ .await?;
+ Ok(HomePostPageJs {
+ items: page.items,
+ next_cursor: page.next_cursor,
+ sync_cursor,
+ })
+}
+
fn link_post_to_js(post: PostResponse, decrypted: DecryptedPost) -> Result<PostJs, Error> {
Ok(PostJs {
post_id: post.post_id,
@@ -962,40 +990,19 @@ impl SpaceAccountCtxHandle {
.map_err(Into::into)
}
- #[wasm_bindgen(js_name = listFeed)]
- pub async fn list_feed(
+ #[wasm_bindgen(js_name = listHomePosts)]
+ pub async fn list_home_posts(
&self,
space_id: String,
+ after: Option<String>,
cursor: Option<String>,
limit: Option<i32>,
) -> Result<JsValue, Error> {
- let page = self.inner.list_feed(&space_id, cursor, limit).await?;
- swb::to_value(
- &account_post_page_to_js(
- &self.inner,
- ente_space::PostPage {
- items: page
- .items
- .into_iter()
- .map(|item| PostResponse {
- post_id: item.post_id,
- space_id: item.space_id,
- space_slug: item.space_slug.clone(),
- author: item.author,
- encrypted_post_key: item.encrypted_post_key,
- caption_cipher: item.caption_cipher,
- key_version: item.key_version,
- objects: item.objects,
- created_at: item.created_at,
- viewer_liked: item.viewer_liked,
- })
- .collect(),
- next_cursor: page.next_cursor,
- },
- )
- .await?,
- )
- .map_err(Into::into)
+ let page = self
+ .inner
+ .list_home_posts(&space_id, after, cursor, limit)
+ .await?;
+ swb::to_value(&account_home_post_page_to_js(&self.inner, page).await?).map_err(Into::into)
}
#[wasm_bindgen(js_name = unreadStatus)]
diff --git a/rust/crates/space/src/client/mod.rs b/rust/crates/space/src/client/mod.rs
index 72cef2b47e..3a83763c34 100644
--- a/rust/crates/space/src/client/mod.rs
+++ b/rust/crates/space/src/client/mod.rs
@@ -28,11 +28,11 @@ use crate::crypto::{
};
use crate::error::{Error, Result};
use crate::models::{
- CreatedSpace, DecryptedFriendShare, DecryptedSpaceProfile, FeedItem, MessagePayload,
+ CreatedSpace, DecryptedFriendShare, DecryptedSpaceProfile, MessagePayload,
OpenAccountSpaceCtxInput, PostObjectMetadata,
};
use crate::transport::{
- CreateSpaceRequest, FriendShareResponse, PostObjectPayload, PostResponse, SpaceKeyResponse,
+ CreateSpaceRequest, FriendShareResponse, PostObjectPayload, SpaceKeyResponse,
SpaceKeyVersionResponse, SpaceLookupResponse, SpaceProfileResponse, UpdateSpaceSlugRequest,
};
use ente_core::{
@@ -708,21 +708,6 @@ fn validate_message_payload(payload: &MessagePayload, plaintext_len: usize) -> R
Ok(())
}
-fn post_response_from_feed_item(item: &FeedItem) -> PostResponse {
- PostResponse {
- post_id: item.post_id,
- space_id: item.space_id.clone(),
- space_slug: item.space_slug.clone(),
- author: item.author.clone(),
- encrypted_post_key: item.encrypted_post_key.clone(),
- caption_cipher: item.caption_cipher.clone(),
- key_version: item.key_version,
- objects: item.objects.clone(),
- created_at: item.created_at.clone(),
- viewer_liked: item.viewer_liked,
- }
-}
-
pub(super) fn build_api(
base_url: &str,
space_session_token: Option<String>,
diff --git a/rust/crates/space/src/client/posts.rs b/rust/crates/space/src/client/posts.rs
index 230ad9fe81..3f1c9ec323 100644
--- a/rust/crates/space/src/client/posts.rs
+++ b/rust/crates/space/src/client/posts.rs
@@ -1,13 +1,11 @@
-use super::{
- AccountSpaceCtx, decrypt_post_object_metadata, ensure_post_objects_are_photos,
- post_response_from_feed_item,
-};
+use super::{AccountSpaceCtx, decrypt_post_object_metadata, ensure_post_objects_are_photos};
use crate::crypto::{decrypt_secretbox_payload, encrypt_secretbox_payload, generate_key};
use crate::error::{Error, Result};
-use crate::models::{DecryptedPost, FeedItem, FeedPage, HydratedKeys, PostObjectMetadata};
+use crate::models::{DecryptedPost, HydratedKeys, PostObjectMetadata};
use crate::transport::{
- CreatePostRequest, CreatePostResponse, LikePostResponse, PostObjectPayload, PostPage,
- PostResponse, SpaceActorResponse, SpaceUnreadStatusResponse, UpdatePostCaptionRequest,
+ CreatePostRequest, CreatePostResponse, HomePostPage, LikePostResponse, PostObjectPayload,
+ PostPage, PostResponse, SpaceActorResponse, SpaceUnreadStatusResponse,
+ UpdatePostCaptionRequest,
};
use ente_core::{b64, http};
@@ -94,21 +92,25 @@ impl AccountSpaceCtx {
.await?)
}
- pub async fn list_feed(
+ pub async fn list_home_posts(
&self,
space_id: &str,
+ after: Option<String>,
cursor: Option<String>,
limit: Option<i32>,
- ) -> Result<FeedPage> {
+ ) -> Result<HomePostPage> {
let mut query = Vec::new();
+ if let Some(value) = after.filter(|value| !value.trim().is_empty()) {
+ query.push(("after", value));
+ }
if let Some(value) = cursor.filter(|value| !value.trim().is_empty()) {
query.push(("cursor", value));
}
if let Some(value) = limit {
query.push(("limit", value.to_string()));
}
- let path = format!("/spaces/{space_id}/feed");
- let fetch_feed = async {
+ let path = format!("/spaces/{space_id}/home-posts");
+ let fetch_home_posts = async {
Ok(self
.api()
.get(&path)
@@ -120,7 +122,7 @@ impl AccountSpaceCtx {
.await?)
};
let (page, _) = futures_util::try_join!(
- fetch_feed,
+ fetch_home_posts,
self.list_decrypted_friend_shares_cached(space_id)
)?;
Ok(page)
@@ -345,11 +347,6 @@ impl AccountSpaceCtx {
)?))
}
- pub async fn decrypt_feed_item(&self, item: &FeedItem) -> Result<DecryptedPost> {
- let post = post_response_from_feed_item(item);
- self.decrypt_post_for_space(&item.space_id, &post).await
- }
-
pub async fn update_post_caption(
&self,
space_id: &str,
diff --git a/rust/crates/space/src/client/tests.rs b/rust/crates/space/src/client/tests.rs
index daa4a723cd..fac15f37f1 100644
--- a/rust/crates/space/src/client/tests.rs
+++ b/rust/crates/space/src/client/tests.rs
@@ -1754,7 +1754,7 @@ async fn refresh_friend_shares_accepts_empty_server_response() {
}
#[tokio::test]
-async fn list_feed_uses_space_feed_endpoint() {
+async fn list_home_posts_uses_home_posts_endpoint() {
let mut server = Server::new_async().await;
let ctx = test_account_ctx(&server.url());
let shares = server
@@ -1764,10 +1764,11 @@ async fn list_feed_uses_space_feed_endpoint() {
.with_body("[]")
.create_async()
.await;
- let feed = server
- .mock("GET", "/spaces/space_owner_main/feed")
+ let home_posts = server
+ .mock("GET", "/spaces/space_owner_main/home-posts")
.match_header("x-space-session-token", "space-session-token")
.match_query(Matcher::AllOf(vec![
+ Matcher::UrlEncoded("after".into(), "1000:1".into()),
Matcher::UrlEncoded("cursor".into(), "cursor-1".into()),
Matcher::UrlEncoded("limit".into(), "5".into()),
]))
@@ -1776,8 +1777,8 @@ async fn list_feed_uses_space_feed_endpoint() {
json!({
"items": [{
"postId": 42,
- "spaceId": "space_owner_main",
- "spaceSlug": "owner-main",
+ "spaceId": "space_friend_gallery",
+ "spaceSlug": "friend-gallery",
"author": {
"spaceId": "space_owner_gallery",
"spaceSlug": "owner-gallery"
@@ -1789,7 +1790,8 @@ async fn list_feed_uses_space_feed_endpoint() {
"createdAt": "2026-04-16T00:00:00Z",
"viewerLiked": true
}],
- "nextCursor": "cursor-2"
+ "nextCursor": "cursor-2",
+ "syncCursor": "2000:42"
})
.to_string(),
)
@@ -1797,15 +1799,21 @@ async fn list_feed_uses_space_feed_endpoint() {
.await;
let page = ctx
- .list_feed("space_owner_main", Some("cursor-1".to_owned()), Some(5))
+ .list_home_posts(
+ "space_owner_main",
+ Some("1000:1".to_owned()),
+ Some("cursor-1".to_owned()),
+ Some(5),
+ )
.await
- .expect("feed page should load");
+ .expect("home posts should load");
assert_eq!(page.items.len(), 1);
assert_eq!(page.items[0].post_id, 42);
assert_eq!(page.next_cursor, "cursor-2");
+ assert_eq!(page.sync_cursor, "2000:42");
shares.assert_async().await;
- feed.assert_async().await;
+ home_posts.assert_async().await;
}
#[tokio::test]
diff --git a/rust/crates/space/src/lib.rs b/rust/crates/space/src/lib.rs
index dd4479235b..454f529fc3 100644
--- a/rust/crates/space/src/lib.rs
+++ b/rust/crates/space/src/lib.rs
@@ -15,15 +15,16 @@ pub use crypto::{decrypt_space_root_entity_key, encrypt_space_root_entity_key};
pub use error::{Error, Result};
pub use models::{
CreatedSpace, CreatedSpaceLink, DecryptedFriendShare, DecryptedMessage, DecryptedPost,
- DecryptedSpaceProfile, FeedItem, FeedPage, HydratedKeys, MessagePayload,
- OpenAccountSpaceCtxInput, OpenSpaceLinkCtxInput, PostObjectMetadata,
+ DecryptedSpaceProfile, HydratedKeys, MessagePayload, OpenAccountSpaceCtxInput,
+ OpenSpaceLinkCtxInput, PostObjectMetadata,
};
pub use transport::{
ConversationChatSummaryResponse, ConversationsResponse, EntityKeyPayload,
- FriendRelationshipResponse, FriendShareResponse, FriendStatusResponse, LikeMessageResponse,
- LikePostResponse, MessageConversationActivity, MessagePage, MessageResponse, PostObjectPayload,
- PostPage, PostResponse, PresignUploadResponse, ProfileAvatarPayload, ProfileAvatarResponse,
- ProfileCoverPayload, ProfileCoverResponse, SpaceActorResponse, SpaceFriendRequestResponse,
- SpaceFriendResponse, SpaceKeyResponse, SpaceKeyVersionResponse, SpaceLookupResponse,
- SpaceProfileResponse, SpaceSentFriendRequestResponse, SpaceUnreadStatusResponse,
+ FriendRelationshipResponse, FriendShareResponse, FriendStatusResponse, HomePostPage,
+ LikeMessageResponse, LikePostResponse, MessageConversationActivity, MessagePage,
+ MessageResponse, PostObjectPayload, PostPage, PostResponse, PresignUploadResponse,
+ ProfileAvatarPayload, ProfileAvatarResponse, ProfileCoverPayload, ProfileCoverResponse,
+ SpaceActorResponse, SpaceFriendRequestResponse, SpaceFriendResponse, SpaceKeyResponse,
+ SpaceKeyVersionResponse, SpaceLookupResponse, SpaceProfileResponse,
+ SpaceSentFriendRequestResponse, SpaceUnreadStatusResponse,
};
diff --git a/rust/crates/space/src/models.rs b/rust/crates/space/src/models.rs
index 90ceacfe17..b2fd8a7744 100644
--- a/rust/crates/space/src/models.rs
+++ b/rust/crates/space/src/models.rs
@@ -1,10 +1,7 @@
use serde::{Deserialize, Serialize};
use zeroize::ZeroizeOnDrop;
-use crate::transport::{
- PostObjectPayload, ProfileAvatarResponse, ProfileCoverResponse, SpaceActorResponse,
- SpaceKeyResponse,
-};
+use crate::transport::{ProfileAvatarResponse, ProfileCoverResponse, SpaceKeyResponse};
#[derive(Clone)]
pub struct OpenAccountSpaceCtxInput {
@@ -102,31 +99,6 @@ pub struct DecryptedFriendShare {
pub key_version: i32,
}
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
-#[serde(rename_all = "camelCase")]
-pub struct FeedItem {
- pub post_id: i64,
- pub space_id: String,
- pub space_slug: String,
- pub author: SpaceActorResponse,
- pub encrypted_post_key: String,
- #[serde(default)]
- pub caption_cipher: String,
- pub key_version: i32,
- #[serde(default)]
- pub objects: Vec<PostObjectPayload>,
- pub created_at: String,
- pub viewer_liked: bool,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
-#[serde(rename_all = "camelCase")]
-pub struct FeedPage {
- pub items: Vec<FeedItem>,
- #[serde(default)]
- pub next_cursor: String,
-}
-
#[derive(Clone)]
pub struct HydratedKeys {
pub owned: Vec<(String, Vec<u8>)>,
diff --git a/rust/crates/space/src/transport.rs b/rust/crates/space/src/transport.rs
index 01013b0a56..5ea905cb23 100644
--- a/rust/crates/space/src/transport.rs
+++ b/rust/crates/space/src/transport.rs
@@ -256,6 +256,15 @@ pub struct PostPage {
pub next_cursor: String,
}
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct HomePostPage {
+ pub items: Vec<PostResponse>,
+ #[serde(default)]
+ pub next_cursor: String,
+ pub sync_cursor: String,
+}
+
#[derive(Debug, Clone, Serialize, Deserialize, Default, PartialEq, Eq)]
#[serde(rename_all = "camelCase")]
pub struct SpaceActorResponse {
diff --git a/rust/crates/space/tests/space.rs b/rust/crates/space/tests/space.rs
index c2892b3580..279ddb5014 100644
--- a/rust/crates/space/tests/space.rs
+++ b/rust/crates/space/tests/space.rs
@@ -152,25 +152,11 @@ async fn space_bootstrap_posts_and_friend_share_suite(endpoint: &str) {
owner_post.caption_plaintext.as_deref(),
Some(br#"{"caption":"hello world"}"#.as_slice())
);
- let owner_feed = owner_ctx
- .list_feed(&owner_space.space_id, None, Some(10))
+ let owner_home_posts = owner_ctx
+ .list_home_posts(&owner_space.space_id, None, None, Some(10))
.await
- .expect("owner feed should include own post");
- let owner_feed_post = owner_feed
- .items
- .iter()
- .find(|item| item.post_id == post_id)
- .expect("own post should be in owner feed");
- assert_eq!(owner_feed_post.space_id, owner_space.space_id);
- assert!(!owner_feed_post.viewer_liked);
- let owner_feed_decrypted = owner_ctx
- .decrypt_feed_item(owner_feed_post)
- .await
- .expect("owner should decrypt own feed item");
- assert_eq!(
- owner_feed_decrypted.caption_plaintext.as_deref(),
- Some(br#"{"caption":"hello world"}"#.as_slice())
- );
+ .expect("owner home posts should load");
+ assert!(owner_home_posts.items.is_empty());
space::assert_http_status(
owner_ctx
.like_post(&owner_space.space_id, post_id, true)
@@ -227,28 +213,28 @@ async fn space_bootstrap_posts_and_friend_share_suite(endpoint: &str) {
assert_eq!(owner_view_of_friend.profile, friend_profile_payload);
assert_eq!(owner_view_of_friend.space_slug, friend_slug);
- let feed = friend_ctx
- .list_feed(&friend_space.space_id, None, Some(10))
+ let home_posts = friend_ctx
+ .list_home_posts(&friend_space.space_id, None, None, Some(10))
.await
- .expect("feed should load after friend approval");
- assert_eq!(feed.items.len(), 1);
- assert_eq!(feed.items[0].post_id, post_id);
- assert_eq!(feed.items[0].author.space_id, owner_space.space_id);
- assert_eq!(feed.items[0].author.space_slug, updated_slug);
- let feed_author_profile = friend_ctx
- .decrypt_actor_profile(&feed.items[0].author)
+ .expect("home posts should load after friend approval");
+ assert_eq!(home_posts.items.len(), 1);
+ assert_eq!(home_posts.items[0].post_id, post_id);
+ assert_eq!(home_posts.items[0].author.space_id, owner_space.space_id);
+ assert_eq!(home_posts.items[0].author.space_slug, updated_slug);
+ let home_post_author_profile = friend_ctx
+ .decrypt_actor_profile(&home_posts.items[0].author)
.await
- .expect("friend should decrypt feed author profile");
+ .expect("friend should decrypt home post author profile");
assert_eq!(
- feed_author_profile.as_deref(),
+ home_post_author_profile.as_deref(),
Some(updated_profile.as_slice())
);
- let feed_post = friend_ctx
- .decrypt_feed_item(&feed.items[0])
+ let home_post = friend_ctx
+ .decrypt_post_for_space(&home_posts.items[0].space_id, &home_posts.items[0])
.await
- .expect("feed item should decrypt");
+ .expect("home post should decrypt");
assert_eq!(
- feed_post.caption_plaintext.as_deref(),
+ home_post.caption_plaintext.as_deref(),
Some(br#"{"caption":"hello world"}"#.as_slice())
);
@@ -349,11 +335,11 @@ async fn space_unfriend_revokes_reciprocal_account_access_suite(endpoint: &str)
.await
.expect("owner should decrypt friend profile before unfriend");
assert_eq!(owner_friend_profile.profile, friend_profile);
- let feed = friend_ctx
- .list_feed(&friend_space.space_id, None, Some(10))
+ let home_posts = friend_ctx
+ .list_home_posts(&friend_space.space_id, None, None, Some(10))
.await
- .expect("friend feed should load before unfriend");
- assert!(feed.items.iter().any(|item| item.post_id == post_id));
+ .expect("friend home posts should load before unfriend");
+ assert!(home_posts.items.iter().any(|item| item.post_id == post_id));
friend_ctx
.like_post(&friend_space.space_id, post_id, true)
.await
@@ -433,12 +419,13 @@ async fn space_unfriend_revokes_reciprocal_account_access_suite(endpoint: &str)
.expect("friend space keys should hydrate after unfriend");
assert_eq!(hydrated.owned.len(), 1);
assert!(hydrated.friends.is_empty());
- let feed = friend_ctx
- .list_feed(&friend_space.space_id, None, Some(10))
+ let home_posts = friend_ctx
+ .list_home_posts(&friend_space.space_id, None, None, Some(10))
.await
- .expect("friend feed should load after unfriend");
+ .expect("friend home posts should load after unfriend");
assert!(
- feed.items
+ home_posts
+ .items
.iter()
.all(|item| item.space_id != owner_space.space_id)
);
diff --git a/server/pkg/middleware/rate_limit.go b/server/pkg/middleware/rate_limit.go
index 0856696ce9..b2b9ebaaa8 100644
--- a/server/pkg/middleware/rate_limit.go
+++ b/server/pkg/middleware/rate_limit.go
@@ -226,7 +226,7 @@ func (r *RateLimitMiddleware) getLimiter(reqPath string, reqMethod string) *limi
if reqPath == "/spaces/:spaceID/conversations" && reqMethod == http.MethodGet {
return r.limit60ReqPerMin
}
- if reqPath == "/spaces/:spaceID/feed" && reqMethod == http.MethodGet {
+ if reqPath == "/spaces/:spaceID/home-posts" && reqMethod == http.MethodGet {
return r.limit60ReqPerMin
}
if reqMethod == http.MethodGet && isSpaceViewerReadURLPath(reqPath) {
diff --git a/server/space/api/posts.go b/server/space/api/posts.go
index 48e846cafc..9474047db8 100644
--- a/server/space/api/posts.go
+++ b/server/space/api/posts.go
@@ -15,12 +15,12 @@ func (h *Handlers) CreatePost(c *gin.Context, space *spacerepo.SpaceRecord) {
respondJSON(c, resp, err)
}
-func (h *Handlers) ListFeed(c *gin.Context, space *spacerepo.SpaceRecord) {
- var req models.ListFeedRequest
+func (h *Handlers) ListHomePosts(c *gin.Context, space *spacerepo.SpaceRecord) {
+ var req models.ListHomePostsRequest
if !bindQuery(c, &req) {
return
}
- resp, err := h.Module.Posts.ListFeed(c, space, req)
+ resp, err := h.Module.Posts.ListHomePosts(c, space, req)
respondJSON(c, resp, err)
}
diff --git a/server/space/api/register.go b/server/space/api/register.go
index 7e332a4aa3..82b517afb1 100644
--- a/server/space/api/register.go
+++ b/server/space/api/register.go
@@ -16,7 +16,7 @@ func Register(privateAPI, publicAPI gin.IRouter, handlers *Handlers) {
spaceAPI.POST("/uploads/presign", selected(handlers.PresignUpload))
spaceAPI.GET("/unread", selected(handlers.GetUnreadStatus))
spaceAPI.POST("/posts", selected(handlers.CreatePost))
- spaceAPI.GET("/feed", selected(handlers.ListFeed))
+ spaceAPI.GET("/home-posts", selected(handlers.ListHomePosts))
spaceAPI.POST("/posts/:postID/caption", selected(handlers.UpdatePostCaption))
spaceAPI.PATCH("/posts/:postID/caption", selected(handlers.UpdatePostCaption))
spaceAPI.PUT("/posts/:postID/like", selected(handlers.LikePost))
diff --git a/server/space/controller/posts.go b/server/space/controller/posts.go
index 3f40232f3d..3636fd2116 100644
--- a/server/space/controller/posts.go
+++ b/server/space/controller/posts.go
@@ -5,6 +5,7 @@ import (
"database/sql"
"errors"
"fmt"
+ "strconv"
"strings"
"github.com/ente/museum/ente"
@@ -152,8 +153,12 @@ func (c *PostsController) List(ctx *gin.Context, req models.ListPostsRequest) (*
}, nil
}
-func (c *PostsController) ListFeed(ctx context.Context, viewerSpace *repo.SpaceRecord, req models.ListFeedRequest) (*models.FeedPage, error) {
- posts, nextCursor, err := c.PostsRepo.ListFeed(ctx, viewerSpace.SpaceID, req.Cursor, req.Limit)
+func (c *PostsController) ListHomePosts(ctx context.Context, viewerSpace *repo.SpaceRecord, req models.ListHomePostsRequest) (*models.HomePostPage, error) {
+ syncCreatedAt, err := c.PostsRepo.CurrentDatabaseTimeMicroseconds(ctx)
+ if err != nil {
+ return nil, err
+ }
+ posts, nextCursor, err := c.PostsRepo.ListHomePosts(ctx, viewerSpace.SpaceID, req.After, req.Cursor, req.Limit)
if err != nil {
return nil, err
}
@@ -161,9 +166,15 @@ func (c *PostsController) ListFeed(ctx context.Context, viewerSpace *repo.SpaceR
if err != nil {
return nil, err
}
- return &models.FeedPage{
+ syncPostID := int64(0)
+ if len(posts) > 0 && posts[0].CreatedAt >= syncCreatedAt {
+ syncCreatedAt = posts[0].CreatedAt
+ syncPostID = posts[0].PostID
+ }
+ return &models.HomePostPage{
Items: items,
NextCursor: nextCursor,
+ SyncCursor: strconv.FormatInt(syncCreatedAt, 10) + ":" + strconv.FormatInt(syncPostID, 10),
}, nil
}
diff --git a/server/space/controller/posts_test.go b/server/space/controller/posts_test.go
index 00ef9131ce..247df1ac57 100644
--- a/server/space/controller/posts_test.go
+++ b/server/space/controller/posts_test.go
@@ -3,6 +3,8 @@ package controller
import (
"crypto/sha256"
"database/sql"
+ "strconv"
+ "strings"
"testing"
timeutil "github.com/ente/museum/pkg/utils/time"
@@ -98,3 +100,25 @@ func TestListPostsHydratesPostAssets(t *testing.T) {
require.Equal(t, 1, page.Items[0].Objects[0].Position)
require.Equal(t, "bWV0YWRhdGE=", page.Items[0].Objects[0].MetadataCipher)
}
+
+func TestListHomePostsSyncCursorUsesDatabaseTime(t *testing.T) {
+ controller, repos, ctx := setupPostsControllerTest(t)
+ aliceID := insertSpaceControllerUser(t, repos, "[email protected]", "alice-public")
+ aliceSpace, err := testCreateSpace(ctx, repos, aliceID, "alice_home_sync", "alice-space-key", "alice-home-sync-public", "alice-home-sync-secret", "alice-home-sync-secret-nonce", "alice-profile")
+ require.NoError(t, err)
+
+ before, err := repos.Posts.CurrentDatabaseTimeMicroseconds(ctx)
+ require.NoError(t, err)
+ page, err := controller.ListHomePosts(ctx, aliceSpace, models.ListHomePostsRequest{Limit: 10})
+ require.NoError(t, err)
+ after, err := repos.Posts.CurrentDatabaseTimeMicroseconds(ctx)
+ require.NoError(t, err)
+
+ createdAt, postID, found := strings.Cut(page.SyncCursor, ":")
+ require.True(t, found)
+ syncCreatedAt, err := strconv.ParseInt(createdAt, 10, 64)
+ require.NoError(t, err)
+ require.Equal(t, "0", postID)
+ require.GreaterOrEqual(t, syncCreatedAt, before)
+ require.LessOrEqual(t, syncCreatedAt, after)
+}
diff --git a/server/space/models/models.go b/server/space/models/models.go
index 60cf55c9c2..cd6b677d56 100644
--- a/server/space/models/models.go
+++ b/server/space/models/models.go
@@ -55,7 +55,8 @@ type ListPostsRequest struct {
Limit int `form:"limit"`
}
-type ListFeedRequest struct {
+type ListHomePostsRequest struct {
+ After string `form:"after"`
Cursor string `form:"cursor"`
Limit int `form:"limit"`
}
@@ -401,7 +402,8 @@ type PostPage struct {
NextCursor string `json:"nextCursor,omitempty"`
}
-type FeedPage struct {
+type HomePostPage struct {
Items []PostResponse `json:"items"`
NextCursor string `json:"nextCursor,omitempty"`
+ SyncCursor string `json:"syncCursor"`
}
diff --git a/server/space/repo/module_test.go b/server/space/repo/module_test.go
index e4a638b73b..745eca90c6 100644
--- a/server/space/repo/module_test.go
+++ b/server/space/repo/module_test.go
@@ -2044,7 +2044,7 @@ func TestListPostsBySpaceCursorUsesCreatedAtSortOrder(t *testing.T) {
require.Equal(t, "2000:"+strconv.FormatInt(second, 10), nextCursor)
}
-func TestListFeedCursorUsesCreatedAtSortOrder(t *testing.T) {
+func TestListHomePostsReturnsFriendLatestAndPostsAfterCursor(t *testing.T) {
ctx := context.Background()
module := newSpaceTestModule(t)
@@ -2076,30 +2076,52 @@ func TestListFeedCursorUsesCreatedAtSortOrder(t *testing.T) {
setPostCreatedAt(t, module, 2000, second)
setPostCreatedAt(t, module, 1000, third)
- page, nextCursor, err := module.Posts.ListFeed(ctx, aliceSpace.SpaceID, "", 1)
+ page, nextCursor, err := module.Posts.ListHomePosts(ctx, aliceSpace.SpaceID, "", "", 10)
require.NoError(t, err)
require.Len(t, page, 1)
- require.Equal(t, ownPost, page[0].PostID)
- require.Equal(t, aliceSpace.SpaceID, page[0].SpaceID)
+ require.Equal(t, first, page[0].PostID)
+ require.Equal(t, bobSpace.SpaceID, page[0].SpaceID)
require.False(t, page[0].ViewerLiked)
- require.Equal(t, "5000:"+strconv.FormatInt(ownPost, 10), nextCursor)
+ require.Empty(t, nextCursor)
- page, nextCursor, err = module.Posts.ListFeed(ctx, aliceSpace.SpaceID, nextCursor, 1)
+ page, nextCursor, err = module.Posts.ListHomePosts(ctx, aliceSpace.SpaceID, "1500:0", "", 10)
+ require.NoError(t, err)
+ require.Len(t, page, 2)
+ require.Equal(t, first, page[0].PostID)
+ require.Equal(t, second, page[1].PostID)
+ require.Empty(t, nextCursor)
+
+ after := "1000:" + strconv.FormatInt(third, 10)
+ page, nextCursor, err = module.Posts.ListHomePosts(ctx, aliceSpace.SpaceID, after, "", 1)
require.NoError(t, err)
require.Len(t, page, 1)
require.Equal(t, first, page[0].PostID)
require.Equal(t, "3000:"+strconv.FormatInt(first, 10), nextCursor)
- page, nextCursor, err = module.Posts.ListFeed(ctx, aliceSpace.SpaceID, nextCursor, 1)
+ page, nextCursor, err = module.Posts.ListHomePosts(ctx, aliceSpace.SpaceID, after, nextCursor, 1)
require.NoError(t, err)
require.Len(t, page, 1)
require.Equal(t, second, page[0].PostID)
- require.Equal(t, "2000:"+strconv.FormatInt(second, 10), nextCursor)
+ require.Empty(t, nextCursor)
- page, nextCursor, err = module.Posts.ListFeed(ctx, aliceSpace.SpaceID, nextCursor, 1)
+ page, nextCursor, err = module.Posts.ListHomePosts(ctx, aliceSpace.SpaceID, "3000:"+strconv.FormatInt(first, 10), "", 10)
require.NoError(t, err)
require.Len(t, page, 1)
- require.Equal(t, third, page[0].PostID)
+ require.Equal(t, first, page[0].PostID)
+ require.Empty(t, nextCursor)
+
+ require.NoError(t, module.Posts.UpdateCaption(ctx, second, bobSpace.SpaceID, testSpaceBytes("updated-caption")))
+ page, nextCursor, err = module.Posts.ListHomePosts(ctx, aliceSpace.SpaceID, "1500:0", "", 10)
+ require.NoError(t, err)
+ require.Len(t, page, 2)
+ require.Equal(t, testSpaceBytes("updated-caption"), page[1].CaptionCipher)
+ require.Empty(t, nextCursor)
+
+ require.NoError(t, module.Posts.DeletePost(ctx, second, bobSpace.SpaceID))
+ page, nextCursor, err = module.Posts.ListHomePosts(ctx, aliceSpace.SpaceID, "1500:0", "", 10)
+ require.NoError(t, err)
+ require.Len(t, page, 1)
+ require.Equal(t, first, page[0].PostID)
require.Empty(t, nextCursor)
}
diff --git a/server/space/repo/posts.go b/server/space/repo/posts.go
index a7e02626e4..c097edb9d5 100644
--- a/server/space/repo/posts.go
+++ b/server/space/repo/posts.go
@@ -15,6 +15,14 @@ const MaxPostsPerSpace = 250
var ErrSpacePostLimitReached = errors.New("space post limit reached")
+func (r *PostsRepository) CurrentDatabaseTimeMicroseconds(ctx context.Context) (int64, error) {
+ var currentTime int64
+ if err := r.DB.QueryRowContext(ctx, `SELECT now_utc_micro_seconds()`).Scan(&currentTime); err != nil {
+ return 0, stacktrace.Propagate(err, "")
+ }
+ return currentTime, nil
+}
+
func (r *PostsRepository) CountPosts(ctx context.Context, spaceID string) (int64, error) {
var count int64
if err := r.DB.QueryRowContext(ctx, `
@@ -179,34 +187,41 @@ func (r *PostsRepository) ListPostsBySpace(ctx context.Context, spaceID string,
return out, nextCursor, nil
}
-func (r *PostsRepository) ListFeed(ctx context.Context, viewerSpaceID string, cursor string, limit int) ([]SpacePostRecord, string, error) {
+func (r *PostsRepository) ListHomePosts(ctx context.Context, viewerSpaceID string, after string, cursor string, limit int) ([]SpacePostRecord, string, error) {
limit = optionalInt(limit, 25)
if limit > 100 {
limit = 100
}
args := []any{viewerSpaceID}
query := postRecordSelectSQL(`
- CASE WHEN p.space_id = $1 THEN FALSE ELSE EXISTS (
+ EXISTS (
SELECT 1
FROM space_messages m
WHERE m.kind = 'post_like'
AND m.reply_post_id = p.post_id
AND m.sender_space_id = $1
- ) END`) + `
+ )`) + `
FROM space_posts p
+ JOIN space_friend_shares fs ON fs.friend_space_id = $1 AND fs.space_id = p.space_id
JOIN spaces w ON w.space_id = p.space_id
` + spaceActorAvatarJoin("w", "w_avatar") + `
JOIN users u ON u.user_id = w.owner_id AND u.encrypted_email IS NOT NULL
WHERE p.is_deleted = FALSE
AND (
- p.space_id = $1 OR EXISTS (
- SELECT 1 FROM space_friend_shares fs
- WHERE fs.friend_space_id = $1 AND fs.space_id = p.space_id
- )
- )`
+ NOT EXISTS (
+ SELECT 1 FROM space_posts newer
+ WHERE newer.space_id = p.space_id
+ AND newer.is_deleted = FALSE
+ AND (newer.created_at, newer.post_id) > (p.created_at, p.post_id)
+ )`
+ if afterCreatedAt, afterPostID, ok := parsePostBoundary(after); ok {
+ args = append(args, afterCreatedAt, afterPostID)
+ query += ` OR (p.created_at, p.post_id) > ($2, $3)`
+ }
+ query += `)`
if cursorCreatedAt, cursorPostID, ok := parsePostCursor(cursor); ok {
args = append(args, cursorCreatedAt, cursorPostID)
- query += ` AND (p.created_at, p.post_id) < ($2, $3)`
+ query += ` AND (p.created_at, p.post_id) < ($` + strconv.Itoa(len(args)-1) + `, $` + strconv.Itoa(len(args)) + `)`
}
args = append(args, limit+1)
query += ` ORDER BY p.created_at DESC, p.post_id DESC LIMIT $` + strconv.Itoa(len(args))
@@ -395,6 +410,14 @@ func scanPostRecord(scanner interface{ Scan(dest ...any) error }) (*SpacePostRec
}
func parsePostCursor(cursor string) (int64, int64, bool) {
+ return parsePostPosition(cursor, false)
+}
+
+func parsePostBoundary(cursor string) (int64, int64, bool) {
+ return parsePostPosition(cursor, true)
+}
+
+func parsePostPosition(cursor string, allowZeroPostID bool) (int64, int64, bool) {
createdAtText, postIDText, ok := strings.Cut(strings.TrimSpace(cursor), ":")
if !ok {
return 0, 0, false
@@ -404,7 +427,7 @@ func parsePostCursor(cursor string) (int64, int64, bool) {
return 0, 0, false
}
postID, err := strconv.ParseInt(postIDText, 10, 64)
- if err != nil || postID <= 0 {
+ if err != nil || postID < 0 || (!allowZeroPostID && postID == 0) {
return 0, 0, false
}
return createdAt, postID, true
diff --git a/web/apps/space/src/components/AuthenticatedFriendProfile.tsx b/web/apps/space/src/components/AuthenticatedFriendProfile.tsx
index cf64d22f9d..93fe3ad96b 100644
--- a/web/apps/space/src/components/AuthenticatedFriendProfile.tsx
+++ b/web/apps/space/src/components/AuthenticatedFriendProfile.tsx
@@ -11,9 +11,10 @@ import {
} from "screens/ProfileImageViewerScreen";
import { ProfileScreen } from "screens/ProfileScreen";
import {
- patchCachedSpaceFeedPost,
- removeCachedSpaceFeedPostsBySpace,
-} from "services/feed-cache";
+ markSpaceHomePostRead,
+ patchCachedSpaceHomePost,
+ removeCachedSpaceHomePostsBySpace,
+} from "services/home-posts";
import {
loadCurrentSpacePostAssetURL,
loadCurrentSpaceProfile,
@@ -139,7 +140,7 @@ export const AuthenticatedFriendProfile: React.FC<
if (!actorSpaceId) return;
await removeCurrentSpaceFriend(actorSpaceId, friendSpaceId);
- await removeCachedSpaceFeedPostsBySpace(actorSpaceId, friendSpaceId);
+ await removeCachedSpaceHomePostsBySpace(actorSpaceId, friendSpaceId);
}, [friendSpaceId, profile?.spaceId]);
if (profileLoadStatus != "ready" || !profile?.spaceId) {
@@ -175,12 +176,21 @@ export const AuthenticatedFriendProfile: React.FC<
}
onOpenProfileCover={() => setOpenProfileImage("cover")}
onOpenProfilePhoto={() => setOpenProfileImage("avatar")}
+ onOpenPost={(post) => {
+ if (!post.postId) return;
+ void markSpaceHomePostRead(actorSpaceId, {
+ postId: post.postId,
+ timestampMs: post.timestampMs,
+ }).catch((error: unknown) =>
+ log.warn("Failed to mark Space post as read", error),
+ );
+ }}
onReplyToPost={(postSpaceId, postId, text) =>
replyToCurrentPost(actorSpaceId, postSpaceId, postId, text)
}
onSetPostLiked={async (postId, liked) => {
await setCurrentPostLiked(actorSpaceId, postId, liked);
- void patchCachedSpaceFeedPost(actorSpaceId, postId, {
+ void patchCachedSpaceHomePost(actorSpaceId, postId, {
viewerLiked: liked,
});
}}
diff --git a/web/apps/space/src/components/FileViewer.tsx b/web/apps/space/src/components/FileViewer.tsx
index 8ff8a28f7b..ada7a84223 100644
--- a/web/apps/space/src/components/FileViewer.tsx
+++ b/web/apps/space/src/components/FileViewer.tsx
@@ -58,7 +58,6 @@ const defaultPhotoHeight = 680;
const viewerSwipeMinDeltaPx = 72;
const viewerSwipeAxisRatio = 1.5;
const viewerHeaderAvatarSize = 28;
-const viewerHeaderButtonVisualSize = 28;
const draftPostExitDurationMs = 320;
const keyboardInsetThresholdPx = 80;
const keyboardDismissMaxDurationMs = 500;
@@ -182,6 +181,7 @@ interface SpaceFileViewerProps {
photos?: SpaceViewerPhoto[];
focusReplyOnOpen?: boolean;
postActionMode?: SpaceViewerPostActionMode;
+ showSequenceProgress?: boolean;
}
interface ViewerSwipeGesture {
@@ -244,7 +244,7 @@ const viewerActionButtonSx = {
"&:hover": { bgcolor: controlBackgroundHover },
};
-export const SpaceViewerFeedBackdrop: React.FC<{ exiting?: boolean }> = ({
+export const SpaceViewerPostBackdrop: React.FC<{ exiting?: boolean }> = ({
exiting = false,
}) => (
<Box
@@ -270,28 +270,17 @@ const viewerHeaderButtonSx = {
bgcolor: "transparent",
border: 0,
borderRadius: "50%",
- color: controlIcon,
+ color: "#E4E4E4",
cursor: "pointer",
display: "flex",
height: spaceTouchTargetSize,
justifyContent: "center",
+ left: "8px",
mx: "-8px",
p: 0,
+ position: "relative",
width: spaceTouchTargetSize,
"&:focus-visible": { outline: `2px solid ${green}`, outlineOffset: 2 },
- "&:hover .space-viewer-header-button-visual": {
- bgcolor: controlBackgroundHover,
- },
-};
-
-const viewerHeaderButtonVisualSx = {
- alignItems: "center",
- bgcolor: controlBackground,
- borderRadius: "50%",
- display: "flex",
- height: viewerHeaderButtonVisualSize,
- justifyContent: "center",
- width: viewerHeaderButtonVisualSize,
};
const resizeCaptionInput = (
@@ -377,6 +366,7 @@ export const SpaceFileViewer: React.FC<SpaceFileViewerProps> = ({
photoIndex = 0,
photos,
postActionMode = "like-only",
+ showSequenceProgress = false,
}) => {
const activePostActionMode = postActionMode;
const isDraftPost = activePostActionMode == "draft-post";
@@ -404,6 +394,8 @@ export const SpaceFileViewer: React.FC<SpaceFileViewerProps> = ({
viewerPhotos.length - 1,
);
const activePhoto = viewerPhotos[activePhotoIndex] ?? photo;
+ const shouldShowSequenceProgress =
+ showSequenceProgress && !isDraftPost && viewerPhotos.length > 1;
const canUpdatePostCaption =
!isDraftPost &&
Boolean(activePhoto.postId) &&
@@ -1437,6 +1429,40 @@ export const SpaceFileViewer: React.FC<SpaceFileViewerProps> = ({
justifySelf: "flex-end",
}}
>
+ {shouldShowSequenceProgress && (
+ <Box
+ component="span"
+ aria-label={`Post ${activePhotoIndex + 1} of ${viewerPhotos.length}`}
+ sx={{
+ alignItems: "center",
+ bgcolor: controlBackground,
+ borderRadius: "999px",
+ boxSizing: "border-box",
+ display: "inline-flex",
+ fontFamily:
+ '"Inter Variable", Inter, sans-serif',
+ fontSize: 12,
+ fontVariantNumeric: "tabular-nums",
+ fontWeight: 700,
+ gap: "6px",
+ height: 28,
+ justifyContent: "center",
+ lineHeight: "16px",
+ minWidth: 48,
+ px: "9px",
+ }}
+ >
+ <Box component="span" sx={{ color: "#70EC80" }}>
+ {activePhotoIndex + 1}
+ </Box>
+ <Box component="span" sx={{ color: textTertiary }}>
+ /
+ </Box>
+ <Box component="span" sx={{ color: textBase }}>
+ {viewerPhotos.length}
+ </Box>
+ </Box>
+ )}
{canManagePost && !isCaptionEditing && (
<Box
component="button"
@@ -1488,17 +1514,11 @@ export const SpaceFileViewer: React.FC<SpaceFileViewerProps> = ({
onClick={closeViewer}
sx={viewerHeaderButtonSx}
>
- <Box
- className="space-viewer-header-button-visual"
- component="span"
- sx={viewerHeaderButtonVisualSx}
- >
- <HugeiconsIcon
- icon={Cancel01Icon}
- size={18}
- strokeWidth={1.8}
- />
- </Box>
+ <HugeiconsIcon
+ icon={Cancel01Icon}
+ size={18}
+ strokeWidth={1.8}
+ />
</Box>
</Box>
{canManagePost && (
diff --git a/web/apps/space/src/pages/app/friends/index.tsx b/web/apps/space/src/pages/app/friends/index.tsx
index 6af9b55233..7151c19130 100644
--- a/web/apps/space/src/pages/app/friends/index.tsx
+++ b/web/apps/space/src/pages/app/friends/index.tsx
@@ -4,10 +4,7 @@ import { SpaceRouteFallback } from "components/RouteFallback";
import log from "ente-base/log";
import React, { useEffect } from "react";
import { FriendsScreen, friendsBackground } from "screens/FriendsScreen";
-import {
- invalidateCachedSpaceFeed,
- removeCachedSpaceFeedPostsBySpace,
-} from "services/feed-cache";
+import { removeCachedSpaceHomePostsBySpace } from "services/home-posts";
import { spaceInviteURL } from "services/invite";
import {
clearSpaceFriendsCache,
@@ -103,7 +100,6 @@ const Page: React.FC = () => {
try {
if (status == "friend") {
clearSpaceFriendsCache();
- void invalidateCachedSpaceFeed(actorSpaceId);
const [requests, friends] = await Promise.all([
loadCurrentFriendRequests(actorSpaceId),
loadCurrentSpaceFriends(actorSpaceId),
@@ -166,7 +162,6 @@ const Page: React.FC = () => {
setShowFriendRequestCanceledToast(true);
return;
}
- void invalidateCachedSpaceFeed(actorSpaceId);
const friends = await loadCurrentSpaceFriends(actorSpaceId);
setFriendRequests((currentRequests) =>
currentRequests.filter(
@@ -224,7 +219,7 @@ const Page: React.FC = () => {
actorSpaceId,
friend.spaceId,
);
- await removeCachedSpaceFeedPostsBySpace(
+ await removeCachedSpaceHomePostsBySpace(
actorSpaceId,
friend.spaceId,
);
diff --git a/web/apps/space/src/pages/app/index.tsx b/web/apps/space/src/pages/app/index.tsx
index abc2c9a8a9..5693cbfe47 100644
--- a/web/apps/space/src/pages/app/index.tsx
+++ b/web/apps/space/src/pages/app/index.tsx
@@ -4,17 +4,17 @@ import log from "ente-base/log";
import React, { useEffect, useState } from "react";
import { HomeScreen, homeBackground } from "screens/HomeScreen";
import {
- patchCachedSpaceFeedPost,
- prependCachedSpaceFeedPost,
-} from "services/feed-cache";
+ loadSpaceHomePosts,
+ patchCachedSpaceHomePost,
+ refreshSpaceHomePosts,
+} from "services/home-posts";
import { consumeSentSpaceInviteFriend } from "services/invite";
import { loadExistingSpaceId } from "services/profile";
import {
createCurrentPhotoPost,
+ loadCurrentFriendAvatarURL,
loadCurrentSpaceFriends,
- loadCurrentSpaceLatestPost,
loadCurrentSpacePostAssetURL,
- loadCurrentSpacePostAvatarURL,
loadCurrentUnreadStatus,
replyToCurrentPost,
setCurrentPostLiked,
@@ -39,6 +39,7 @@ const Page: React.FC = () => {
const [friendRequestSentToastName, setFriendRequestSentToastName] =
useState<string>();
const [latestPosts, setLatestPosts] = useState<SpacePost[]>([]);
+ const [unreadPosts, setUnreadPosts] = useState<SpacePost[]>([]);
const [hasUnreadMessages, setHasUnreadMessages] = useState<boolean>();
const [isLatestPostsLoading, setIsLatestPostsLoading] = useState(true);
const [isFriendsLoading, setIsFriendsLoading] = useState(true);
@@ -64,15 +65,18 @@ const Page: React.FC = () => {
}, [router.isReady]);
useEffect(() => {
- let cancelled = false;
+ const request = { cancelled: false };
+ const isCancelled = () => request.cancelled;
setSpaceId(undefined);
setLatestPosts([]);
+ setUnreadPosts([]);
setHasUnreadMessages(undefined);
setIsLatestPostsLoading(true);
setIsFriendsLoading(true);
- void loadExistingSpaceId()
- .then((nextSpaceId) => {
- if (cancelled) return;
+ void (async () => {
+ try {
+ const nextSpaceId = await loadExistingSpaceId();
+ if (isCancelled()) return;
setSpaceId(nextSpaceId);
if (!nextSpaceId) {
@@ -82,7 +86,7 @@ const Page: React.FC = () => {
void loadCurrentUnreadStatus(nextSpaceId)
.then((unreadStatus) => {
- if (!cancelled) {
+ if (!isCancelled()) {
setHasUnreadMessages(unreadStatus.messagesUnread);
}
})
@@ -90,52 +94,39 @@ const Page: React.FC = () => {
log.error("Failed to load space unread status", error),
);
- return loadCurrentSpaceFriends(nextSpaceId).then(
- (nextFriends) => {
- if (cancelled) return;
+ const [nextFriends, savedHomePosts] = await Promise.all([
+ loadCurrentSpaceFriends(nextSpaceId),
+ loadSpaceHomePosts(nextSpaceId),
+ ]);
+ if (isCancelled()) return;
- setFriends(nextFriends);
- setIsFriendsLoading(false);
- return Promise.all(
- nextFriends.map(async (friend) => {
- if (!friend.spaceId) return null;
- try {
- return await loadCurrentSpaceLatestPost(
- friend.spaceId,
- nextSpaceId,
- );
- } catch (error) {
- log.warn(
- `Failed to load latest post for ${friend.id}`,
- error,
- );
- return null;
- }
- }),
- ).then((latestPosts) => {
- if (cancelled) return;
+ setFriends(nextFriends);
+ setIsFriendsLoading(false);
+ if (savedHomePosts) {
+ setLatestPosts(savedHomePosts.latestPosts);
+ setUnreadPosts(savedHomePosts.unreadPosts);
+ setIsLatestPostsLoading(false);
+ }
- setLatestPosts(
- latestPosts.filter(
- (post): post is SpacePost => post !== null,
- ),
- );
- });
- },
+ const refreshedHomePosts = await refreshSpaceHomePosts(
+ nextSpaceId,
+ nextFriends,
);
- })
- .catch((error: unknown) =>
- log.error("Failed to load space friends", error),
- )
- .finally(() => {
- if (cancelled) return;
-
- setIsLatestPostsLoading(false);
- setIsFriendsLoading(false);
- });
+ if (isCancelled() || !refreshedHomePosts) return;
+ setLatestPosts(refreshedHomePosts.latestPosts);
+ setUnreadPosts(refreshedHomePosts.unreadPosts);
+ } catch (error) {
+ log.error("Failed to load Space home posts", error);
+ } finally {
+ if (!isCancelled()) {
+ setIsLatestPostsLoading(false);
+ setIsFriendsLoading(false);
+ }
+ }
+ })();
return () => {
- cancelled = true;
+ request.cancelled = true;
};
}, [setFriends]);
@@ -144,7 +135,7 @@ const Page: React.FC = () => {
if (!spaceId) throw new Error("Missing space.");
await setCurrentPostLiked(spaceId, postId, liked);
- void patchCachedSpaceFeedPost(spaceId, postId, {
+ void patchCachedSpaceHomePost(spaceId, postId, {
viewerLiked: liked,
});
setLatestPosts((currentItems) =>
@@ -154,6 +145,13 @@ const Page: React.FC = () => {
: item,
),
);
+ setUnreadPosts((currentItems) =>
+ currentItems.map((item) =>
+ item.postId == postId
+ ? { ...item, viewerLiked: liked }
+ : item,
+ ),
+ );
},
[spaceId],
);
@@ -175,6 +173,7 @@ const Page: React.FC = () => {
<SpacePageMeta themeColor={homeBackground} />
<HomeScreen
latestPosts={latestPosts}
+ unreadPosts={unreadPosts}
friendRequestSentToastName={friendRequestSentToastName}
friends={friends}
hasUnreadMessages={hasUnreadMessages}
@@ -203,7 +202,7 @@ const Page: React.FC = () => {
image.cropArea,
image.rotationDegrees,
);
- const post = await createCurrentPhotoPost({
+ await createCurrentPhotoPost({
caption,
file: preparedImage.file,
height: preparedImage.height,
@@ -211,7 +210,6 @@ const Page: React.FC = () => {
thumbHash: preparedImage.thumbHash,
width: preparedImage.width,
});
- void prependCachedSpaceFeedPost(spaceId, post);
}
: undefined
}
@@ -229,7 +227,7 @@ const Page: React.FC = () => {
);
}
}}
- onLoadPostAvatar={loadCurrentSpacePostAvatarURL}
+ onLoadFriendAvatar={loadCurrentFriendAvatarURL}
onLoadPostImage={loadCurrentSpacePostAssetURL}
onOpenMessages={() => void router.push(spaceRoutes.messages)}
onOpenProfile={
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 9022b8702c..b679d25949 100644
--- a/web/apps/space/src/pages/app/posts/[spaceId]/[postId].tsx
+++ b/web/apps/space/src/pages/app/posts/[spaceId]/[postId].tsx
@@ -3,7 +3,10 @@ import { SpacePageMeta } from "components/PageMeta";
import { SpaceRouteFallback } from "components/RouteFallback";
import log from "ente-base/log";
import React from "react";
-import { patchCachedSpaceFeedPost } from "services/feed-cache";
+import {
+ markSpaceHomePostRead,
+ patchCachedSpaceHomePost,
+} from "services/home-posts";
import {
loadCurrentSpacePost,
replyToCurrentPost,
@@ -89,12 +92,13 @@ const Page: React.FC = () => {
return;
}
+ const viewerSpaceId = profile.spaceId;
let cancelled = false;
setPost(null);
setPostLoadError(undefined);
setIsPostLoading(true);
- void loadCurrentSpacePost(spaceId, postId, profile.spaceId)
+ void loadCurrentSpacePost(spaceId, postId, viewerSpaceId)
.then((nextPost) => {
if (cancelled) return;
if (!nextPost) {
@@ -102,6 +106,15 @@ const Page: React.FC = () => {
return;
}
setPost(nextPost);
+ if (nextPost.spaceId != viewerSpaceId) {
+ void markSpaceHomePostRead(viewerSpaceId, nextPost).catch(
+ (error: unknown) =>
+ log.warn(
+ "Failed to mark Space post as read",
+ error,
+ ),
+ );
+ }
})
.catch((error: unknown) => {
log.error("Failed to load space post", error);
@@ -185,7 +198,7 @@ const Page: React.FC = () => {
}
onSetPostLiked={async (nextPostId, liked) => {
await setCurrentPostLiked(actorSpaceId, nextPostId, liked);
- void patchCachedSpaceFeedPost(actorSpaceId, nextPostId, {
+ void patchCachedSpaceHomePost(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 dd4706390a..cca5d4950a 100644
--- a/web/apps/space/src/pages/app/profile.tsx
+++ b/web/apps/space/src/pages/app/profile.tsx
@@ -3,16 +3,10 @@ import { SpaceRouteFallback } from "components/RouteFallback";
import log from "ente-base/log";
import React, { useEffect, useMemo, useState } from "react";
import { ProfileScreen, profileBackground } from "screens/ProfileScreen";
-import {
- patchCachedSpaceFeedPost,
- prependCachedSpaceFeedPost,
- removeCachedSpaceFeedPost,
-} from "services/feed-cache";
import { spaceInviteURL } from "services/invite";
import {
createCurrentPhotoPost,
deleteCurrentPost,
- isSpacePostLimitReachedError,
loadCurrentSpaceFriendsCount,
loadCurrentSpacePostAssetURL,
loadCurrentSpaceProfilePostsPage,
@@ -21,11 +15,6 @@ import {
type SpaceProfilePost,
} from "services/space";
import { useSpaceAppState } from "state/app-state";
-import {
- confirmLocalFeedPost,
- createLocalFeedPostID,
- failLocalFeedPost,
-} from "utils/local-feed-post";
import { profilePostItemsFromPosts } from "utils/post-display";
import { prepareSpacePostImageFromEdit } from "utils/post-image";
import { useSpaceRouter } from "utils/route-transitions";
@@ -35,8 +24,7 @@ const initialPostLoadingIndicatorDelayMs = 350;
const Page: React.FC = () => {
const router = useSpaceRouter();
- const { profile, profileLoadError, profileLoadStatus, setLocalFeedPosts } =
- useSpaceAppState();
+ const { profile, profileLoadError, profileLoadStatus } = useSpaceAppState();
const [friendsCount, setFriendsCount] = useState(0);
const [posts, setPosts] = useState<SpaceProfilePost[]>([]);
const [isPostsLoading, setIsPostsLoading] = useState(true);
@@ -136,73 +124,25 @@ const Page: React.FC = () => {
const spaceId = profile.spaceId;
if (!spaceId) throw new Error("Missing space.");
- const localPostId = createLocalFeedPostID();
- const displayName =
- profile.fullName.trim() || profile.username.trim();
- setLocalFeedPosts((currentPosts) => [
- {
- avatarUrl: profile.avatarUrl,
- caption: caption.trim() || undefined,
- friendID: spaceId,
- height: image.height,
- id: localPostId,
- imageUrl:
- image.previewUrl ||
- URL.createObjectURL(image.file),
- name: displayName || "You",
- spaceId,
- status: "pending",
- timestampMs: Date.now(),
- width: image.width,
- },
- ...currentPosts,
- ]);
- try {
- const preparedImage =
- await prepareSpacePostImageFromEdit(
- image.file,
- image.cropArea,
- image.rotationDegrees,
- );
- const post = await createCurrentPhotoPost({
- caption,
- file: preparedImage.file,
- height: preparedImage.height,
- spaceId,
- thumbHash: preparedImage.thumbHash,
- width: preparedImage.width,
- });
- confirmLocalFeedPost(
- setLocalFeedPosts,
- localPostId,
- post,
- );
- void prependCachedSpaceFeedPost(spaceId, post);
- } catch (error) {
- failLocalFeedPost(
- setLocalFeedPosts,
- localPostId,
- isSpacePostLimitReachedError(error)
- ? "post-limit"
- : undefined,
- );
- throw error;
- }
+ const preparedImage = await prepareSpacePostImageFromEdit(
+ image.file,
+ image.cropArea,
+ image.rotationDegrees,
+ );
+ await createCurrentPhotoPost({
+ caption,
+ file: preparedImage.file,
+ height: preparedImage.height,
+ spaceId,
+ thumbHash: preparedImage.thumbHash,
+ width: preparedImage.width,
+ });
}}
onDraftPostPublished={() => void router.push(spaceRoutes.home)}
onDeletePost={async (postId) => {
const spaceId = profile.spaceId;
if (!spaceId) throw new Error("Missing space.");
await deleteCurrentPost(spaceId, postId);
- void removeCachedSpaceFeedPost(spaceId, postId);
- setLocalFeedPosts((currentPosts) =>
- currentPosts.filter(
- (item) =>
- item.status == "pending" ||
- item.status == "failed" ||
- item.post.postId != postId,
- ),
- );
setPosts((currentPosts) =>
currentPosts.filter((post) => post.postId != postId),
);
@@ -213,24 +153,6 @@ 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" ||
- item.status == "ready") &&
- item.post.postId == postId
- ? {
- ...item,
- post: {
- ...item.post,
- caption: normalizedCaption,
- },
- }
- : item,
- ),
- );
setPosts((currentPosts) =>
currentPosts.map((post) =>
post.postId == postId
@@ -250,9 +172,6 @@ const Page: React.FC = () => {
onLoadPostImage={loadCurrentSpacePostAssetURL}
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/pages/layout-demo.tsx b/web/apps/space/src/pages/layout-demo.tsx
index 042dcc89bf..26b6c568e7 100644
--- a/web/apps/space/src/pages/layout-demo.tsx
+++ b/web/apps/space/src/pages/layout-demo.tsx
@@ -1,9 +1,15 @@
import { ArrowLeft02Icon, ArrowRight01Icon } from "@hugeicons/core-free-icons";
import { HugeiconsIcon } from "@hugeicons/react";
import { Box } from "@mui/material";
+import { SpaceAvatarImage } from "components/AvatarImage";
import { SpacePostFloatingActionButton } from "components/PostFloatingActionButton";
import React from "react";
-import { homeCirclePlacements } from "utils/home-circle-layout";
+import {
+ homeCircleGridLayout,
+ homeCirclePlacements,
+ usesHomeCircleGrid,
+ type HomeCirclePlacement,
+} from "utils/home-circle-layout";
const background = "#0C1014";
const headerChromeColor = "#202825";
@@ -17,6 +23,54 @@ interface CanvasSize {
width: number;
}
+const LayoutDemoPost: React.FC<{ placement?: HomeCirclePlacement }> = ({
+ placement,
+}) => {
+ const avatarSize = placement ? Math.min(32, placement.size * 0.2) : "20%";
+ return (
+ <Box
+ sx={{
+ aspectRatio: "1",
+ position: placement ? "absolute" : "relative",
+ width: placement?.size ?? "100%",
+ ...(placement && {
+ height: placement.size,
+ left: placement.x,
+ top: placement.y,
+ }),
+ }}
+ >
+ <Box
+ sx={{
+ bgcolor: "#1A211F",
+ borderRadius: "20%",
+ height: "100%",
+ position: "relative",
+ width: "100%",
+ zIndex: 1,
+ }}
+ />
+ <Box
+ aria-hidden
+ sx={{
+ borderRadius: "50%",
+ bottom: "10%",
+ height: avatarSize,
+ left: "10%",
+ maxHeight: 32,
+ maxWidth: 32,
+ overflow: "hidden",
+ position: "absolute",
+ width: avatarSize,
+ zIndex: 2,
+ }}
+ >
+ <SpaceAvatarImage aria-hidden borderRadius="50%" />
+ </Box>
+ </Box>
+ );
+};
+
const LayoutDemoPage: React.FC = () => {
const [friendCount, setFriendCount] = React.useState(1);
const [canvasSize, setCanvasSize] = React.useState<CanvasSize>({
@@ -53,14 +107,17 @@ const LayoutDemoPage: React.FC = () => {
return () => window.removeEventListener("keydown", handleKeyDown);
}, []);
+ const usesGrid = usesHomeCircleGrid(friendCount);
const placements = homeCirclePlacements(
friendCount,
canvasSize.width,
canvasSize.height,
);
- const circleSize = placements[0]?.size ?? 0;
- const ringWidth = Math.max(1, Math.min(3, circleSize * 0.018));
- const circlePadding = Math.max(1.5, Math.min(4, circleSize * 0.025));
+ const gridLayout = homeCircleGridLayout(
+ friendCount,
+ canvasSize.width,
+ canvasSize.height,
+ );
return (
<Box
@@ -181,57 +238,44 @@ const LayoutDemoPage: React.FC = () => {
</Box>
<Box
sx={{
- bottom: layoutVerticalInset,
- left: "16px",
- position: "absolute",
- right: "16px",
- top: layoutVerticalInset,
+ boxSizing: "border-box",
+ display: "flex",
+ flexDirection: "column",
+ height: `calc(100svh - ${headerHeight}px)`,
+ pb: layoutVerticalInset,
+ pt: `calc(${layoutVerticalInset} - ${headerHeight}px)`,
+ px: "16px",
}}
>
<Box
ref={canvasRef}
sx={{
- height: "100%",
+ display: usesGrid ? "grid" : "block",
+ flex: "1 1 auto",
+ gap: gridLayout ? `${gridLayout.gap}px` : undefined,
+ gridTemplateColumns: gridLayout
+ ? `repeat(3, ${gridLayout.size}px)`
+ : undefined,
+ gridTemplateRows: gridLayout
+ ? `repeat(${gridLayout.rows}, ${gridLayout.size}px)`
+ : undefined,
+ minHeight: 0,
+ placeContent: usesGrid ? "center" : undefined,
position: "relative",
width: "100%",
}}
>
- {circleSize > 0 &&
- placements.map(({ size, x, y }, index) => (
- <Box
- key={index}
- sx={{
- height: size,
- left: x,
- position: "absolute",
- top: y,
- width: size,
- }}
- >
- <Box
- sx={{
- aspectRatio: "1",
- border: `${ringWidth}px solid #2A3430`,
- borderRadius: "50%",
- boxSizing: "border-box",
- height: "100%",
- p: `${circlePadding}px`,
- position: "relative",
- width: "100%",
- zIndex: 1,
- }}
- >
- <Box
- sx={{
- bgcolor: "#1A211F",
- borderRadius: "50%",
- height: "100%",
- width: "100%",
- }}
- />
- </Box>
- </Box>
- ))}
+ {usesGrid && gridLayout
+ ? Array.from(
+ { length: friendCount },
+ (_, index) => <LayoutDemoPost key={index} />,
+ )
+ : placements.map((placement, index) => (
+ <LayoutDemoPost
+ key={index}
+ placement={placement}
+ />
+ ))}
</Box>
</Box>
<SpacePostFloatingActionButton />
diff --git a/web/apps/space/src/screens/HomeScreen.tsx b/web/apps/space/src/screens/HomeScreen.tsx
index 7935716858..f54a2e6c9c 100644
--- a/web/apps/space/src/screens/HomeScreen.tsx
+++ b/web/apps/space/src/screens/HomeScreen.tsx
@@ -8,7 +8,7 @@ import { Box, Skeleton } from "@mui/material";
import { SpaceAvatarImage } from "components/AvatarImage";
import {
SpaceFileViewer,
- SpaceViewerFeedBackdrop,
+ SpaceViewerPostBackdrop,
type SpaceViewerDraftPostEdit,
type SpaceViewerPhoto,
type SpaceViewerPostActionMode,
@@ -21,16 +21,18 @@ import log from "ente-base/log";
import { useBrowserBackClose } from "hooks/use-browser-back-close";
import React, { useState } from "react";
import type { SetupProfile } from "screens/SetupProfileScreen";
+import { markSpaceHomePostRead } from "services/home-posts";
import {
isSpaceContentError,
type SpacePost,
type SpacePostAssetURLLoader,
- type SpacePostAvatarURLLoader,
} from "services/space";
import { spaceTouchTargetSize } from "styles/touch-targets";
import { firstNameFrom } from "utils/display";
import {
+ homeCircleGridLayout,
homeCirclePlacements,
+ usesHomeCircleGrid,
type HomeCirclePlacement,
} from "utils/home-circle-layout";
import { createLoadedLocalPostPhoto } from "utils/local-post-photo";
@@ -45,7 +47,6 @@ import { thumbHashDataURLFromBase64 } from "utils/thumbhash";
export const homeBackground = "#0C1014";
const green = "#08C225";
-const inactivePostCircleBorderColor = "rgba(180, 195, 186, 0.1)";
const mediaSkeletonElementBackground = "#E6E6E6";
const textBase = "#000";
const textSecondary = "#6B6B6B";
@@ -67,6 +68,7 @@ const avatarFadeSx = {
} as const;
interface HomeScreenProps {
latestPosts: SpacePost[];
+ unreadPosts: SpacePost[];
friendRequestSentToastName?: string;
friends: FriendProfile[];
hasUnreadMessages?: boolean;
@@ -78,7 +80,7 @@ interface HomeScreenProps {
image: DraftSpacePostImage,
caption: string,
) => Promise<void>;
- onLoadPostAvatar?: SpacePostAvatarURLLoader;
+ onLoadFriendAvatar?: (friend: FriendProfile) => Promise<string | null>;
onLoadPostImage?: SpacePostAssetURLLoader;
onFriendRequestSentToastClose?: () => void;
onInitialPostPhotoConsumed?: () => void;
@@ -109,13 +111,17 @@ interface PostCircleCanvasSize {
}
interface SelectedHomeViewer {
+ avatarUrl?: string | null;
draftFile?: File;
draftImageError?: string;
focusReplyOnOpen?: boolean;
+ friend?: FriendProfile;
isDraftImagePreviewPending?: boolean;
localObjectUrl?: string;
photo: SpaceViewerPhoto;
+ postIndex?: number;
postActionMode?: SpaceViewerPostActionMode;
+ posts?: SpacePost[];
}
interface DraftSpacePostImage {
@@ -131,6 +137,30 @@ interface AddedFriendToastProps {
onClose?: () => void;
}
+const viewerPhotoForPost = (
+ post: SpacePost,
+ friend: FriendProfile,
+ avatarUrl: string | null | undefined,
+ imageUrl: string,
+): SpaceViewerPhoto => {
+ const displayName = friend.fullName.trim() || friend.username.trim();
+ return {
+ alt: `${displayName} post`,
+ avatarUrl,
+ caption: post.caption,
+ friendID: post.friendID,
+ height: post.height,
+ imageUrl,
+ name: displayName,
+ postId: post.postId,
+ spaceId: post.spaceId,
+ timestampMs: post.timestampMs,
+ username: friend.username,
+ viewerLiked: post.viewerLiked,
+ width: post.width,
+ };
+};
+
const postImageCacheKey = (item: SpacePost) =>
[
item.postId,
@@ -138,13 +168,13 @@ const postImageCacheKey = (item: SpacePost) =>
item.imageAsset?.objectKey ?? item.imageUrl ?? "",
].join(":");
-const postAvatarCacheKey = (item: SpacePost) =>
+const friendAvatarCacheKey = (friend: FriendProfile) =>
[
- item.spaceId,
- item.avatarKeyVersion ?? "",
- item.avatarObjectID ?? "",
- item.avatarUpdatedAt ?? "",
- item.avatarSize ?? "",
+ friend.spaceId ?? friend.id,
+ friend.avatarKeyVersion ?? "",
+ friend.avatarObjectID ?? "",
+ friend.avatarUpdatedAt ?? "",
+ friend.avatarSize ?? "",
].join(":");
const useDecodedImage = (
@@ -216,13 +246,18 @@ interface FriendPostCircleProps {
imageUrl?: string;
isAvatarPending: boolean;
isLoading: boolean;
+ isRead: boolean;
isUnavailable: boolean;
onLoadAvatar?: () => Promise<string | null | undefined>;
onLoadImage?: () => Promise<string | undefined>;
onOpenFriend?: (friendID: string, username?: string) => void;
- onOpenPhoto: (photo: SpaceViewerPhoto) => void;
- placement: HomeCirclePlacement;
- post?: SpacePost;
+ onOpenPosts: (
+ friend: FriendProfile,
+ posts: SpacePost[],
+ photo: SpaceViewerPhoto,
+ ) => void;
+ placement?: HomeCirclePlacement;
+ posts: SpacePost[];
}
const FriendPostCircle: React.FC<FriendPostCircleProps> = ({
@@ -231,13 +266,14 @@ const FriendPostCircle: React.FC<FriendPostCircleProps> = ({
imageUrl,
isAvatarPending,
isLoading,
+ isRead,
isUnavailable,
onLoadAvatar,
onLoadImage,
onOpenFriend,
- onOpenPhoto,
+ onOpenPosts,
placement,
- post,
+ posts,
}) => {
const rootRef = React.useRef<HTMLLIElement | null>(null);
const [shouldLoadMedia, setShouldLoadMedia] = useState(Boolean(imageUrl));
@@ -246,6 +282,7 @@ const FriendPostCircle: React.FC<FriendPostCircleProps> = ({
avatarUrl ?? friend.avatarUrl ?? null,
true,
);
+ const post = posts[0];
const thumbHashDataURL = React.useMemo(
() => thumbHashDataURLFromBase64(post?.thumbHash),
[post?.thumbHash],
@@ -270,11 +307,13 @@ const FriendPostCircle: React.FC<FriendPostCircleProps> = ({
const canOpenPost = Boolean(post) && !postUnavailable && isPhotoReady;
const isCircleDisabled =
isLoading || Boolean(post && !postUnavailable && !isPhotoReady);
- const circleBorderWidth = Math.max(1, Math.min(3, placement.size * 0.018));
- const circlePadding = Math.max(1.5, Math.min(4, placement.size * 0.025));
+ const avatarSize = placement ? Math.min(32, placement.size * 0.2) : "20%";
+
+ const hasMediaToLoad =
+ isAvatarPending || Boolean(post && !postUnavailable && !imageUrl);
React.useEffect(() => {
- if (isLoading || !post || postUnavailable || shouldLoadMedia) return;
+ if (isLoading || !hasMediaToLoad || shouldLoadMedia) return;
const element = rootRef.current;
if (!element) return;
if (
@@ -296,11 +335,11 @@ const FriendPostCircle: React.FC<FriendPostCircleProps> = ({
);
observer.observe(element);
return () => observer.disconnect();
- }, [isLoading, post, postUnavailable, shouldLoadMedia]);
+ }, [hasMediaToLoad, isLoading, shouldLoadMedia]);
React.useEffect(() => {
- if (!shouldLoadMedia || postUnavailable) return;
- if (!imageUrl) void onLoadImage?.();
+ if (!shouldLoadMedia) return;
+ if (!imageUrl && !postUnavailable) void onLoadImage?.();
if (isAvatarPending) void onLoadAvatar?.();
}, [
imageUrl,
@@ -318,7 +357,7 @@ const FriendPostCircle: React.FC<FriendPostCircleProps> = ({
}
if (!canOpenPost || !displayImageUrl) return;
- onOpenPhoto({
+ onOpenPosts(friend, posts, {
alt: `${displayName} post`,
avatarUrl: displayAvatarUrl,
caption: post.caption,
@@ -341,137 +380,171 @@ const FriendPostCircle: React.FC<FriendPostCircleProps> = ({
component="li"
sx={{
aspectRatio: "1",
- left: placement.x,
listStyle: "none",
minWidth: 0,
- position: "absolute",
- top: placement.y,
- transition:
- "left 420ms cubic-bezier(0.2, 0.8, 0.2, 1), top 420ms cubic-bezier(0.2, 0.8, 0.2, 1), width 420ms cubic-bezier(0.2, 0.8, 0.2, 1)",
- width: placement.size,
+ position: placement ? "absolute" : "relative",
+ transition: placement
+ ? "left 420ms cubic-bezier(0.2, 0.8, 0.2, 1), top 420ms cubic-bezier(0.2, 0.8, 0.2, 1), width 420ms cubic-bezier(0.2, 0.8, 0.2, 1)"
+ : "none",
+ width: placement?.size ?? "100%",
+ ...(placement && { left: placement.x, top: placement.y }),
"@media (prefers-reduced-motion: reduce)": {
transition: "none",
},
}}
>
<Box
+ component="button"
+ type="button"
+ aria-label={
+ isLoading
+ ? `Loading ${firstName}'s latest post`
+ : post && !postUnavailable
+ ? posts.length > 1
+ ? `Open ${posts.length} new posts from ${firstName}`
+ : isRead
+ ? `Open ${firstName}'s latest post`
+ : `Open ${firstName}'s new post`
+ : `Open ${firstName}'s profile`
+ }
+ disabled={isCircleDisabled}
+ onClick={openCircle}
sx={{
+ alignItems: "center",
+ appearance: "none",
aspectRatio: "1",
- border: `${circleBorderWidth}px solid ${inactivePostCircleBorderColor}`,
- borderRadius: "50%",
- boxSizing: "border-box",
+ bgcolor: post && isRead ? "#000" : "#E5E7EA",
+ border: 0,
+ borderRadius: "20%",
+ color: textBase,
+ cursor: isCircleDisabled ? "default" : "pointer",
+ display: "flex",
+ fontFamily: '"Inter Variable", Inter, sans-serif',
height: "100%",
- p: `${circlePadding}px`,
+ justifyContent: "center",
+ overflow: "hidden",
+ p: 0,
position: "relative",
width: "100%",
zIndex: 1,
}}
>
- <Box
- component="button"
- type="button"
- aria-label={
- isLoading
- ? `Loading ${firstName}'s latest post`
- : post && !postUnavailable
- ? `Open ${firstName}'s latest post`
- : `Open ${firstName}'s profile`
- }
- disabled={isCircleDisabled}
- onClick={openCircle}
- sx={{
- alignItems: "center",
- appearance: "none",
- aspectRatio: "1",
- bgcolor: "#E5E7EA",
- border: 0,
- borderRadius: "50%",
- color: textBase,
- cursor: isCircleDisabled ? "default" : "pointer",
- display: "flex",
- fontFamily: '"Inter Variable", Inter, sans-serif',
- height: "100%",
- justifyContent: "center",
- overflow: "hidden",
- p: 0,
- position: "relative",
- width: "100%",
- }}
- >
- {isLoading ? (
- <Skeleton
- variant="circular"
- sx={{
- bgcolor: mediaSkeletonElementBackground,
- height: "100%",
- transform: "none",
- width: "100%",
- }}
- />
- ) : post && !postUnavailable ? (
- <>
- {!thumbHashDataURL && !isPhotoReady && (
- <Skeleton
- variant="circular"
- sx={{
- bgcolor: mediaSkeletonElementBackground,
- height: "100%",
- transform: "none",
- width: "100%",
- }}
- />
- )}
- {thumbHashDataURL && (
- <Box
- component="img"
- alt=""
- aria-hidden
- src={thumbHashDataURL}
- sx={{
- filter: "blur(14px)",
- height: "100%",
- inset: 0,
- objectFit: "cover",
- position: "absolute",
- transform: "scale(1.08)",
- width: "100%",
- }}
- />
- )}
- {isPhotoReady && (
- <Box
- component="img"
- alt={`${displayName} post`}
- src={displayImageUrl}
- sx={{
- height: "100%",
- inset: 0,
- objectFit: "cover",
- position: "absolute",
- width: "100%",
- }}
- />
- )}
- </>
- ) : (
- <Box
- sx={{
- alignItems: "center",
- background:
- "linear-gradient(145deg, #ECF7ED, #D9EDDC)",
- color: green,
- display: "flex",
- fontSize: 40,
- fontWeight: 700,
- height: "100%",
- justifyContent: "center",
- width: "100%",
- }}
- >
- {initial}
- </Box>
- )}
- </Box>
+ {isLoading ? (
+ <Skeleton
+ variant="rectangular"
+ sx={{
+ bgcolor: mediaSkeletonElementBackground,
+ height: "100%",
+ transform: "none",
+ width: "100%",
+ }}
+ />
+ ) : post && !postUnavailable ? (
+ <>
+ {!thumbHashDataURL && !isPhotoReady && (
+ <Skeleton
+ variant="rectangular"
+ sx={{
+ bgcolor: mediaSkeletonElementBackground,
+ height: "100%",
+ transform: "none",
+ width: "100%",
+ }}
+ />
+ )}
+ {thumbHashDataURL && (
+ <Box
+ component="img"
+ alt=""
+ aria-hidden
+ src={thumbHashDataURL}
+ sx={{
+ filter: isRead
+ ? "blur(14px) brightness(0.2)"
+ : "blur(14px)",
+ height: "100%",
+ inset: 0,
+ objectFit: "cover",
+ position: "absolute",
+ transform: "scale(1.08)",
+ width: "100%",
+ }}
+ />
+ )}
+ {isPhotoReady && (
+ <Box
+ component="img"
+ alt={`${displayName} post`}
+ src={displayImageUrl}
+ sx={{
+ animation: isRead
+ ? "none"
+ : "spaceNewPostImageFade 520ms cubic-bezier(0.16, 1, 0.3, 1) both",
+ filter: isRead ? "brightness(0.2)" : "none",
+ height: "100%",
+ inset: 0,
+ objectFit: "cover",
+ position: "absolute",
+ width: "100%",
+ "@keyframes spaceNewPostImageFade": {
+ from: { opacity: 0 },
+ to: { opacity: 1 },
+ },
+ "@media (prefers-reduced-motion: reduce)": {
+ animation: "none",
+ },
+ }}
+ />
+ )}
+ </>
+ ) : (
+ <Box
+ sx={{
+ alignItems: "center",
+ background:
+ "linear-gradient(145deg, #ECF7ED, #D9EDDC)",
+ color: green,
+ display: "flex",
+ fontSize: 40,
+ fontWeight: 700,
+ height: "100%",
+ justifyContent: "center",
+ width: "100%",
+ }}
+ >
+ {initial}
+ </Box>
+ )}
+ </Box>
+ <Box
+ component="button"
+ type="button"
+ aria-label={`Open ${firstName}'s profile`}
+ disabled={!onOpenFriend}
+ onClick={() => onOpenFriend?.(friend.id, friend.username)}
+ sx={{
+ appearance: "none",
+ bgcolor: "transparent",
+ border: 0,
+ borderRadius: "50%",
+ bottom: "10%",
+ cursor: onOpenFriend ? "pointer" : "default",
+ height: avatarSize,
+ left: "10%",
+ maxHeight: 32,
+ maxWidth: 32,
+ overflow: "hidden",
+ p: 0,
+ position: "absolute",
+ width: avatarSize,
+ zIndex: 2,
+ }}
+ >
+ <SpaceAvatarImage
+ aria-hidden
+ borderRadius="50%"
+ src={displayAvatarUrl}
+ />
</Box>
</Box>
);
@@ -575,6 +648,7 @@ const AddedFriendToast: React.FC<AddedFriendToastProps> = ({
export const HomeScreen: React.FC<HomeScreenProps> = ({
latestPosts,
+ unreadPosts,
friendRequestSentToastName,
friends,
hasUnreadMessages,
@@ -583,7 +657,7 @@ export const HomeScreen: React.FC<HomeScreenProps> = ({
isFriendsLoading = false,
showInstallPrompt = false,
onCreatePost,
- onLoadPostAvatar,
+ onLoadFriendAvatar,
onLoadPostImage,
onFriendRequestSentToastClose,
onInitialPostPhotoConsumed,
@@ -597,15 +671,15 @@ export const HomeScreen: React.FC<HomeScreenProps> = ({
}) => {
const [selectedViewer, setSelectedViewer] =
useState<SelectedHomeViewer | null>(null);
+ const [openedPostIds, setOpenedPostIds] = useState<Set<number>>(new Set());
const [postCircleCanvasSize, setPostCircleCanvasSize] =
useState<PostCircleCanvasSize>({ height: 0, width: 0 });
const [isDraftPostExitAnimating, setIsDraftPostExitAnimating] =
useState(false);
const [isDraftPostExiting, setIsDraftPostExiting] = useState(false);
const [isPostPhotoOpening, setIsPostPhotoOpening] = useState(false);
- const [loadedPostAvatarURLsByKey, setLoadedPostAvatarURLsByKey] = useState<
- Record<string, string | null>
- >({});
+ const [loadedFriendAvatarURLsByKey, setLoadedFriendAvatarURLsByKey] =
+ useState<Record<string, string | null>>({});
const [loadedPostImageURLsByKey, setLoadedPostImageURLsByKey] = useState<
Record<string, string>
>({});
@@ -636,6 +710,23 @@ export const HomeScreen: React.FC<HomeScreenProps> = ({
}
return posts;
}, [latestPosts]);
+ const unreadPostsByFriendID = React.useMemo(() => {
+ const postsByFriendID = new Map<string, SpacePost[]>();
+ for (const post of unreadPosts) {
+ if (openedPostIds.has(post.postId)) continue;
+ for (const friendID of new Set([post.friendID, post.spaceId])) {
+ const posts = postsByFriendID.get(friendID) ?? [];
+ posts.push(post);
+ postsByFriendID.set(friendID, posts);
+ }
+ }
+ for (const posts of postsByFriendID.values()) {
+ posts.sort(
+ (a, b) => b.timestampMs - a.timestampMs || b.postId - a.postId,
+ );
+ }
+ return postsByFriendID;
+ }, [openedPostIds, unreadPosts]);
const orderedFriends = React.useMemo(
() =>
[...friends].sort((a, b) =>
@@ -643,6 +734,7 @@ export const HomeScreen: React.FC<HomeScreenProps> = ({
),
[friends],
);
+ React.useEffect(() => setOpenedPostIds(new Set()), [viewerSpaceId]);
React.useEffect(() => {
const canvas = postCircleCanvasRef.current;
if (!canvas) return;
@@ -661,6 +753,12 @@ export const HomeScreen: React.FC<HomeScreenProps> = ({
postCircleCanvasSize.width,
postCircleCanvasSize.height,
);
+ const usesPostGrid = usesHomeCircleGrid(orderedFriends.length);
+ const postGridLayout = homeCircleGridLayout(
+ orderedFriends.length,
+ postCircleCanvasSize.width,
+ postCircleCanvasSize.height,
+ );
const isInstallPromptEnabled =
showInstallPrompt && !friendRequestSentToastName && !selectedViewer;
const showUnreadIndicator = hasUnreadMessages === true;
@@ -682,16 +780,37 @@ export const HomeScreen: React.FC<HomeScreenProps> = ({
postInputRef.current?.click();
};
- const openPostPhoto = (
+ const markPostRead = React.useCallback(
+ (post: Pick<SpacePost, "postId" | "timestampMs">) => {
+ if (!viewerSpaceId) return;
+ setOpenedPostIds((current) => new Set(current).add(post.postId));
+ void markSpaceHomePostRead(viewerSpaceId, post).catch(
+ (error: unknown) =>
+ log.warn("Failed to mark Space post as read", error),
+ );
+ },
+ [viewerSpaceId],
+ );
+ const openPostPhotos = (
+ friend: FriendProfile,
+ posts: SpacePost[],
photo: SpaceViewerPhoto,
- focusReplyOnOpen = false,
) => {
+ if (photo.postId) {
+ markPostRead({
+ postId: photo.postId,
+ timestampMs: photo.timestampMs,
+ });
+ }
const isOwnPost =
Boolean(viewerSpaceId) && photo.friendID == viewerSpaceId;
setSelectedViewer({
- focusReplyOnOpen: isOwnPost ? false : focusReplyOnOpen,
+ avatarUrl: photo.avatarUrl,
+ friend,
photo,
+ postIndex: 0,
postActionMode: isOwnPost ? "hidden" : "like-only",
+ posts,
});
};
const closeSelectedPhoto = () => {
@@ -714,13 +833,11 @@ export const HomeScreen: React.FC<HomeScreenProps> = ({
item.imageUrl ?? loadedPostImageURLsByKey[postImageCacheKey(item)],
[loadedPostImageURLsByKey],
);
- const loadedPostAvatarURLFor = React.useCallback(
- (item: SpacePost) => {
- if (item.avatarUrl) return item.avatarUrl;
- if (!item.avatarObjectID) return null;
- return loadedPostAvatarURLsByKey[postAvatarCacheKey(item)];
- },
- [loadedPostAvatarURLsByKey],
+ const loadedFriendAvatarURLFor = React.useCallback(
+ (friend: FriendProfile) =>
+ friend.avatarUrl ??
+ loadedFriendAvatarURLsByKey[friendAvatarCacheKey(friend)],
+ [loadedFriendAvatarURLsByKey],
);
const loadPostImage = React.useCallback(
(item: SpacePost) => {
@@ -764,23 +881,23 @@ export const HomeScreen: React.FC<HomeScreenProps> = ({
},
[loadedPostImageURLFor, onLoadPostImage, unavailablePostsByKey],
);
- const loadPostAvatar = React.useCallback(
- (item: SpacePost) => {
- const loadedAvatarUrl = loadedPostAvatarURLFor(item);
+ const loadFriendAvatar = React.useCallback(
+ (friend: FriendProfile) => {
+ const loadedAvatarUrl = loadedFriendAvatarURLFor(friend);
if (loadedAvatarUrl !== undefined) {
return Promise.resolve(loadedAvatarUrl);
}
- if (!item.avatarObjectID || !onLoadPostAvatar) {
+ if (!friend.avatarObjectID || !onLoadFriendAvatar) {
return Promise.resolve(null);
}
- const cacheKey = postAvatarCacheKey(item);
+ const cacheKey = friendAvatarCacheKey(friend);
const inFlight = avatarLoadsInFlightRef.current.get(cacheKey);
if (inFlight) return inFlight;
- const load = onLoadPostAvatar(item)
+ const load = onLoadFriendAvatar(friend)
.then((avatarUrl) => {
- setLoadedPostAvatarURLsByKey((currentURLs) =>
+ setLoadedFriendAvatarURLsByKey((currentURLs) =>
currentURLs[cacheKey] == avatarUrl
? currentURLs
: { ...currentURLs, [cacheKey]: avatarUrl },
@@ -788,8 +905,8 @@ export const HomeScreen: React.FC<HomeScreenProps> = ({
return avatarUrl;
})
.catch((error: unknown) => {
- log.warn("Failed to load latest post avatar", error);
- setLoadedPostAvatarURLsByKey((currentURLs) =>
+ log.warn("Failed to load friend avatar", error);
+ setLoadedFriendAvatarURLsByKey((currentURLs) =>
currentURLs[cacheKey] === null
? currentURLs
: { ...currentURLs, [cacheKey]: null },
@@ -802,44 +919,158 @@ export const HomeScreen: React.FC<HomeScreenProps> = ({
avatarLoadsInFlightRef.current.set(cacheKey, load);
return load;
},
- [loadedPostAvatarURLFor, onLoadPostAvatar],
+ [loadedFriendAvatarURLFor, onLoadFriendAvatar],
+ );
+ const selectedViewerPostIndex = selectedViewer?.postIndex;
+ const selectedViewerPosts = selectedViewer?.posts;
+ const selectedViewerPhotos = React.useMemo(() => {
+ const friend = selectedViewer?.friend;
+ if (!selectedViewerPosts || !friend) return undefined;
+
+ return selectedViewerPosts.map((post) =>
+ viewerPhotoForPost(
+ post,
+ friend,
+ selectedViewer.avatarUrl,
+ loadedPostImageURLFor(post) ??
+ (selectedViewer.photo.postId == post.postId
+ ? selectedViewer.photo.imageUrl
+ : ""),
+ ),
+ );
+ }, [loadedPostImageURLFor, selectedViewer, selectedViewerPosts]);
+ const handleSelectedViewerPostIndexChange = React.useCallback(
+ (postIndex: number) => {
+ const currentViewer = selectedViewer;
+ const post = currentViewer?.posts?.[postIndex];
+ const friend = currentViewer?.friend;
+ if (!post || !friend) return;
+
+ markPostRead(post);
+ const updateSelectedViewer = (imageUrl: string) => {
+ setSelectedViewer((viewer) => {
+ if (
+ !viewer?.posts ||
+ viewer.posts !== currentViewer.posts
+ ) {
+ return viewer;
+ }
+ return {
+ ...viewer,
+ photo: viewerPhotoForPost(
+ post,
+ friend,
+ viewer.avatarUrl,
+ imageUrl,
+ ),
+ postIndex,
+ };
+ });
+ };
+
+ const imageUrl = loadedPostImageURLFor(post);
+ if (imageUrl) {
+ updateSelectedViewer(imageUrl);
+ return;
+ }
+
+ updateSelectedViewer("");
+ void loadPostImage(post).then((loadedImageUrl) => {
+ if (loadedImageUrl) updateSelectedViewer(loadedImageUrl);
+ });
+ },
+ [loadPostImage, loadedPostImageURLFor, markPostRead, selectedViewer],
);
+ const setSelectedViewerPostLiked = React.useCallback(
+ async (postId: number, liked: boolean) => {
+ await onSetPostLiked?.(postId, liked);
+ setSelectedViewer((viewer) =>
+ viewer
+ ? {
+ ...viewer,
+ photo:
+ viewer.photo.postId == postId
+ ? { ...viewer.photo, viewerLiked: liked }
+ : viewer.photo,
+ posts: viewer.posts?.map((post) =>
+ post.postId == postId
+ ? { ...post, viewerLiked: liked }
+ : post,
+ ),
+ }
+ : viewer,
+ );
+ },
+ [onSetPostLiked],
+ );
+
+ React.useEffect(() => {
+ if (!selectedViewerPosts || selectedViewerPostIndex == undefined)
+ return;
+
+ for (const offset of [-1, 1]) {
+ const adjacentPost =
+ selectedViewerPosts[selectedViewerPostIndex + offset];
+ if (!adjacentPost || loadedPostImageURLFor(adjacentPost)) continue;
+ void loadPostImage(adjacentPost);
+ }
+ }, [
+ loadPostImage,
+ loadedPostImageURLFor,
+ selectedViewerPostIndex,
+ selectedViewerPosts,
+ ]);
const friendPostCircleFor = (friend: FriendProfile, index: number) => {
- const placement = postCirclePlacements[index]!;
- const item = latestPostByFriendID.get(friend.spaceId ?? friend.id);
+ const placement = usesPostGrid
+ ? undefined
+ : postCirclePlacements[index];
+ const friendID = friend.spaceId ?? friend.id;
+ const unreadFriendPosts = (
+ unreadPostsByFriendID.get(friendID) ?? []
+ ).filter(
+ (post) =>
+ !post.isUnavailable &&
+ !unavailablePostsByKey[postImageCacheKey(post)],
+ );
+ const latestPost = latestPostByFriendID.get(friendID);
+ const posts =
+ unreadFriendPosts.length > 0
+ ? unreadFriendPosts
+ : latestPost
+ ? [latestPost]
+ : [];
+ const item = posts[0];
const imageUrl = item ? loadedPostImageURLFor(item) : undefined;
- const avatarUrl = item ? loadedPostAvatarURLFor(item) : null;
+ const avatarUrl = loadedFriendAvatarURLFor(friend);
const isAvatarPending = Boolean(
- item && !item.isUnavailable && avatarUrl === undefined,
+ friend.avatarObjectID && avatarUrl === undefined,
);
const isUnavailable = Boolean(
item &&
(item.isUnavailable ||
unavailablePostsByKey[postImageCacheKey(item)]),
);
+ const isRead = unreadFriendPosts.length == 0;
return (
<FriendPostCircle
- key={friend.id}
+ key={`${friend.id}:${item?.postId ?? "empty"}`}
avatarUrl={avatarUrl}
friend={friend}
imageUrl={imageUrl}
isAvatarPending={isAvatarPending}
isLoading={isFriendsLoading || isLatestPostsLoading}
+ isRead={isRead}
isUnavailable={isUnavailable}
- onLoadAvatar={
- item && isAvatarPending
- ? () => loadPostAvatar(item)
- : undefined
- }
+ onLoadAvatar={() => loadFriendAvatar(friend)}
onLoadImage={
item && !imageUrl && !isUnavailable
? () => loadPostImage(item)
: undefined
}
onOpenFriend={onOpenFriend}
- onOpenPhoto={openPostPhoto}
+ onOpenPosts={openPostPhotos}
placement={placement}
- post={item}
+ posts={posts}
/>
);
};
@@ -998,7 +1229,7 @@ export const HomeScreen: React.FC<HomeScreenProps> = ({
}}
>
{selectedViewer && (
- <SpaceViewerFeedBackdrop exiting={isDraftPostExitAnimating} />
+ <SpaceViewerPostBackdrop exiting={isDraftPostExitAnimating} />
)}
<Box
sx={{
@@ -1264,15 +1495,31 @@ export const HomeScreen: React.FC<HomeScreenProps> = ({
component="ul"
aria-label="Friends' latest posts"
sx={{
+ display: usesPostGrid ? "grid" : "block",
+ gap: postGridLayout
+ ? `${postGridLayout.gap}px`
+ : undefined,
+ gridTemplateColumns: postGridLayout
+ ? `repeat(3, ${postGridLayout.size}px)`
+ : undefined,
+ gridTemplateRows: postGridLayout
+ ? `repeat(${postGridLayout.rows}, ${postGridLayout.size}px)`
+ : undefined,
height: "100%",
m: 0,
+ minHeight: 0,
p: 0,
+ placeContent: usesPostGrid
+ ? "center"
+ : undefined,
position: "relative",
width: "100%",
}}
>
- {postCirclePlacements.length ==
- orderedFriends.length &&
+ {((usesPostGrid && postGridLayout) ||
+ (!usesPostGrid &&
+ postCirclePlacements.length ==
+ orderedFriends.length)) &&
orderedFriends.map(friendPostCircleFor)}
</Box>
) : (
@@ -1307,6 +1554,8 @@ export const HomeScreen: React.FC<HomeScreenProps> = ({
<SpaceFileViewer
focusReplyOnOpen={selectedViewer.focusReplyOnOpen}
photo={selectedViewer.photo}
+ photos={selectedViewerPhotos}
+ photoIndex={selectedViewerPostIndex}
draftPostPreparationError={
selectedViewer.draftImageError
}
@@ -1314,6 +1563,15 @@ export const HomeScreen: React.FC<HomeScreenProps> = ({
selectedViewer.isDraftImagePreviewPending
}
postActionMode={selectedViewer.postActionMode}
+ showSequenceProgress={Boolean(
+ selectedViewerPosts &&
+ selectedViewerPosts.length > 1,
+ )}
+ onPhotoIndexChange={
+ selectedViewerPosts
+ ? handleSelectedViewerPostIndexChange
+ : undefined
+ }
onClose={closeSelectedPhoto}
onOpenProfile={
selectedPhotoIsOwn && onOpenProfile
@@ -1339,7 +1597,13 @@ export const HomeScreen: React.FC<HomeScreenProps> = ({
}
: undefined
}
- onSwipeLeft={closeSelectedPhoto}
+ onSwipeLeft={
+ !selectedViewerPosts ||
+ selectedViewerPostIndex ==
+ selectedViewerPosts.length - 1
+ ? closeSelectedPhoto
+ : undefined
+ }
onReplyToPost={
!selectedPhotoIsOwn &&
selectedViewer.photo.friendID != viewerSpaceId
@@ -1374,7 +1638,11 @@ export const HomeScreen: React.FC<HomeScreenProps> = ({
onDraftPostExitStart={() => {
setIsDraftPostExiting(true);
}}
- onSetPostLiked={onSetPostLiked}
+ onSetPostLiked={
+ onSetPostLiked
+ ? setSelectedViewerPostLiked
+ : undefined
+ }
/>
)}
{friendRequestSentToastName ? (
diff --git a/web/apps/space/src/screens/ProfileScreen.tsx b/web/apps/space/src/screens/ProfileScreen.tsx
index a155e1f7dd..1f66ce7e24 100644
--- a/web/apps/space/src/screens/ProfileScreen.tsx
+++ b/web/apps/space/src/screens/ProfileScreen.tsx
@@ -17,7 +17,7 @@ import { SpaceButtonSpinner } from "components/ButtonSpinner";
import { ConfirmationActionSheet } from "components/ConfirmationActionSheet";
import {
SpaceFileViewer,
- SpaceViewerFeedBackdrop,
+ SpaceViewerPostBackdrop,
type SpaceViewerDraftPostEdit,
type SpaceViewerPhoto,
type SpaceViewerPostActionMode,
@@ -462,6 +462,7 @@ interface ProfileScreenProps {
onDeletePost?: (postId: number) => Promise<void> | void;
onDraftPostPublished?: () => void;
onOpenFriends?: () => void;
+ onOpenPost?: (post: ProfilePostItem) => void;
onOpenProfileCover?: () => void;
onOpenProfilePhoto?: () => void;
onOpenSettings?: () => void;
@@ -499,6 +500,7 @@ export const ProfileScreen: React.FC<ProfileScreenProps> = ({
onDeletePost,
onDraftPostPublished,
onOpenFriends,
+ onOpenPost,
onOpenProfileCover,
onOpenProfilePhoto,
onOpenSettings,
@@ -831,6 +833,7 @@ export const ProfileScreen: React.FC<ProfileScreenProps> = ({
(postIndex: number) => {
const item = viewerPostItems[postIndex];
if (!item) return;
+ onOpenPost?.(item);
const updateSelectedPost = (imageUrl: string) => {
setSelectedPost((currentPost) => {
@@ -860,6 +863,7 @@ export const ProfileScreen: React.FC<ProfileScreenProps> = ({
[
loadPostImage,
loadedPostImageURLFor,
+ onOpenPost,
selectedPostForItem,
viewerPostItems,
],
@@ -1023,7 +1027,7 @@ export const ProfileScreen: React.FC<ProfileScreenProps> = ({
}}
>
{selectedPost && (
- <SpaceViewerFeedBackdrop exiting={isDraftPostExitAnimating} />
+ <SpaceViewerPostBackdrop exiting={isDraftPostExitAnimating} />
)}
<Box
sx={{
@@ -1809,6 +1813,7 @@ export const ProfileScreen: React.FC<ProfileScreenProps> = ({
undefined
)
return;
+ onOpenPost?.(item);
setSelectedPost(
selectedPostForItem(
item,
diff --git a/web/apps/space/src/services/feed-cache.ts b/web/apps/space/src/services/feed-cache.ts
deleted file mode 100644
index a177d88359..0000000000
--- a/web/apps/space/src/services/feed-cache.ts
+++ /dev/null
@@ -1,279 +0,0 @@
-import { savedPartialLocalUser } from "ente-accounts/services/accounts-db";
-import { getKV, removeKV, setKV } from "ente-base/kv";
-import log from "ente-base/log";
-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(),
- isUnavailable: z.boolean().optional(),
- name: z.string(),
- postId: z.number(),
- spaceId: z.string(),
- thumbHash: z.string().optional(),
- timestampMs: z.number(),
- username: z.string().optional(),
- 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) {
- log.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) => {
- log.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) {
- log.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/services/home-posts.ts b/web/apps/space/src/services/home-posts.ts
new file mode 100644
index 0000000000..9fbf4db043
--- /dev/null
+++ b/web/apps/space/src/services/home-posts.ts
@@ -0,0 +1,487 @@
+import type { FriendProfile } from "data/friends";
+import { savedPartialLocalUser } from "ente-accounts/services/accounts-db";
+import { getKV, removeKV, setKV } from "ente-base/kv";
+import log from "ente-base/log";
+import { apiOrigin } from "ente-base/origins";
+import { loadCurrentHomePostsPage, type SpacePost } from "services/space";
+import { z } from "zod";
+
+const homePostsVersion = 1;
+
+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(),
+ isUnavailable: z.boolean().optional(),
+ name: z.string(),
+ postId: z.number(),
+ spaceId: z.string(),
+ thumbHash: z.string().optional(),
+ timestampMs: z.number(),
+ username: z.string().optional(),
+ viewerLiked: z.boolean(),
+ width: z.number().optional(),
+});
+
+const PostMarker = z.object({
+ postId: z.number().int().positive(),
+ timestampMs: z.number().nonnegative(),
+});
+
+const SpaceHomePostsStateSchema = z.object({
+ friendSpaceIds: z.string().array(),
+ latestPosts: CachedSpacePost.array(),
+ readAheadPosts: PostMarker.array(),
+ syncCursor: z.string(),
+ unreadPosts: CachedSpacePost.array(),
+ version: z.literal(homePostsVersion),
+ viewerSpaceId: z.string(),
+});
+
+export interface SpaceHomePostsState {
+ friendSpaceIds: string[];
+ latestPosts: SpacePost[];
+ readAheadPosts: SpacePostMarker[];
+ syncCursor: string;
+ unreadPosts: SpacePost[];
+ version: typeof homePostsVersion;
+ viewerSpaceId: string;
+}
+
+interface SpacePostMarker {
+ postId: number;
+ timestampMs: number;
+}
+
+const memoryCache = new Map<string, SpaceHomePostsState | undefined>();
+const cacheOperations = new Map<string, Promise<void>>();
+let cacheGeneration = 0;
+
+const storageScope = async (viewerSpaceId: string) => {
+ const userID = savedPartialLocalUser()?.id;
+ if (!userID) return undefined;
+ return { origin: await apiOrigin(), userID, viewerSpaceId };
+};
+
+const homePostsKey = async (viewerSpaceId: string) => {
+ const scope = await storageScope(viewerSpaceId);
+ return scope
+ ? [
+ "space-home-posts",
+ `v${homePostsVersion}`,
+ scope.origin,
+ scope.userID,
+ viewerSpaceId,
+ ].join(":")
+ : undefined;
+};
+
+const clonePost = (post: SpacePost): SpacePost => ({
+ ...post,
+ imageAsset: post.imageAsset ? { ...post.imageAsset } : undefined,
+});
+
+const cacheablePost = (post: SpacePost) => {
+ const cached = clonePost(post);
+ delete cached.avatarUrl;
+ delete cached.imageUrl;
+ return cached;
+};
+
+const cloneState = (state: SpaceHomePostsState): SpaceHomePostsState => ({
+ ...state,
+ friendSpaceIds: [...state.friendSpaceIds],
+ latestPosts: state.latestPosts.map(clonePost),
+ readAheadPosts: state.readAheadPosts.map((post) => ({ ...post })),
+ unreadPosts: state.unreadPosts.map(clonePost),
+});
+
+const descendingPostOrder = (a: SpacePostMarker, b: SpacePostMarker) =>
+ b.timestampMs - a.timestampMs || b.postId - a.postId;
+
+const isAfter = (post: SpacePostMarker, marker: SpacePostMarker) =>
+ post.timestampMs > marker.timestampMs ||
+ (post.timestampMs == marker.timestampMs && post.postId > marker.postId);
+
+const markerFor = (post: SpacePostMarker): SpacePostMarker => ({
+ postId: post.postId,
+ timestampMs: post.timestampMs,
+});
+
+const markerFromCursor = (cursor: string): SpacePostMarker | undefined => {
+ const parts = cursor.split(":", 2);
+ const createdAt = Number(parts[0]);
+ const postId = Number(parts[1]);
+ if (
+ !Number.isSafeInteger(createdAt) ||
+ createdAt <= 0 ||
+ !Number.isSafeInteger(postId) ||
+ postId < 0
+ ) {
+ return undefined;
+ }
+ return { postId, timestampMs: Math.floor(createdAt / 1000) };
+};
+
+const normalizedState = (state: SpaceHomePostsState): SpaceHomePostsState => ({
+ ...state,
+ friendSpaceIds: [...new Set(state.friendSpaceIds)].sort(),
+ latestPosts: [...state.latestPosts]
+ .sort(descendingPostOrder)
+ .filter(
+ (post, index, posts) =>
+ posts.findIndex((item) => item.spaceId == post.spaceId) ==
+ index,
+ )
+ .map(cacheablePost),
+ readAheadPosts: [...state.readAheadPosts]
+ .sort(descendingPostOrder)
+ .filter(
+ (post, index, posts) =>
+ posts.findIndex((item) => item.postId == post.postId) == index,
+ ),
+ unreadPosts: [...state.unreadPosts]
+ .sort(descendingPostOrder)
+ .filter(
+ (post, index, posts) =>
+ posts.findIndex((item) => item.postId == post.postId) == index,
+ )
+ .map(cacheablePost),
+ version: homePostsVersion,
+});
+
+const enqueueCacheOperation = async (
+ key: string,
+ operation: () => Promise<void>,
+) => {
+ const previous = cacheOperations.get(key) ?? Promise.resolve();
+ const next = previous.catch(() => undefined).then(operation);
+ cacheOperations.set(key, next);
+ try {
+ await next;
+ } finally {
+ if (cacheOperations.get(key) == next) cacheOperations.delete(key);
+ }
+};
+
+const readState = async (
+ key: string,
+): Promise<SpaceHomePostsState | undefined> => {
+ if (memoryCache.has(key)) return memoryCache.get(key);
+ let value: unknown;
+ try {
+ value = await getKV(key);
+ } catch (error) {
+ log.warn("Failed to read Space home posts cache", error);
+ memoryCache.set(key, undefined);
+ return undefined;
+ }
+ const parsed = SpaceHomePostsStateSchema.safeParse(value);
+ const state = parsed.success ? normalizedState(parsed.data) : undefined;
+ memoryCache.set(key, state);
+ if (!parsed.success && value !== undefined) {
+ try {
+ await removeKV(key);
+ } catch (error) {
+ log.warn("Failed to remove invalid Space home posts cache", error);
+ }
+ }
+ return state;
+};
+
+const writeState = async (key: string, state: SpaceHomePostsState) => {
+ const normalized = normalizedState(state);
+ memoryCache.set(key, normalized);
+ try {
+ await setKV(key, normalized);
+ } catch (error) {
+ log.warn("Failed to persist Space home posts cache", error);
+ }
+};
+
+const updateState = async (
+ viewerSpaceId: string,
+ update: (state: SpaceHomePostsState) => SpaceHomePostsState,
+) => {
+ const generation = cacheGeneration;
+ const key = await homePostsKey(viewerSpaceId);
+ if (!key || generation != cacheGeneration) return undefined;
+
+ let nextState: SpaceHomePostsState | undefined;
+ await enqueueCacheOperation(key, async () => {
+ if (generation != cacheGeneration) return;
+ const state = await readState(key);
+ if (
+ generation != cacheGeneration ||
+ state?.viewerSpaceId != viewerSpaceId
+ ) {
+ return;
+ }
+ nextState = normalizedState(update(cloneState(state)));
+ if (generation != cacheGeneration) return;
+ await writeState(key, nextState);
+ if (generation != cacheGeneration) {
+ memoryCache.delete(key);
+ await removeKV(key);
+ nextState = undefined;
+ }
+ });
+ return nextState ? cloneState(nextState) : undefined;
+};
+
+export const loadSpaceHomePosts = async (viewerSpaceId: string) => {
+ const generation = cacheGeneration;
+ const key = await homePostsKey(viewerSpaceId);
+ if (!key || generation != cacheGeneration) return undefined;
+ await cacheOperations.get(key);
+ if (generation != cacheGeneration) return undefined;
+ const state = await readState(key);
+ if (generation != cacheGeneration) {
+ memoryCache.delete(key);
+ return undefined;
+ }
+ return state?.viewerSpaceId == viewerSpaceId
+ ? cloneState(state)
+ : undefined;
+};
+
+const friendSpaceIdsFrom = (friends: FriendProfile[]) =>
+ [...new Set(friends.flatMap((friend) => friend.spaceId ?? []))].sort();
+
+const latestPostsFor = (posts: SpacePost[], friendSpaceIds: Set<string>) => {
+ const latestPosts = new Map<string, SpacePost>();
+ for (const post of posts) {
+ if (
+ friendSpaceIds.has(post.spaceId) &&
+ !latestPosts.has(post.spaceId)
+ ) {
+ latestPosts.set(post.spaceId, post);
+ }
+ }
+ return latestPosts;
+};
+
+const loadAllHomePosts = async (viewerSpaceId: string, after?: string) => {
+ const items = new Array<SpacePost>();
+ let page = await loadCurrentHomePostsPage(viewerSpaceId, after);
+ const syncCursor = page.syncCursor;
+ while (true) {
+ items.push(...page.items);
+ if (!page.nextCursor) break;
+ page = await loadCurrentHomePostsPage(
+ viewerSpaceId,
+ after,
+ page.nextCursor,
+ );
+ }
+ return { items, syncCursor };
+};
+
+const refreshAfterCursor = (state: SpaceHomePostsState) => {
+ const oldestUnreadPost = state.unreadPosts[state.unreadPosts.length - 1];
+ return oldestUnreadPost
+ ? `${oldestUnreadPost.timestampMs * 1000}:0`
+ : state.syncCursor;
+};
+
+const removeLegacyState = async (viewerSpaceId: string) => {
+ const scope = await storageScope(viewerSpaceId);
+ if (!scope) return;
+ try {
+ await Promise.all([
+ removeKV(
+ [
+ "space-feed",
+ "v1",
+ scope.origin,
+ scope.userID,
+ viewerSpaceId,
+ ].join(":"),
+ ),
+ removeKV(
+ [
+ "space-post-read-state",
+ "v1",
+ scope.origin,
+ scope.userID,
+ viewerSpaceId,
+ ].join(":"),
+ ),
+ ]);
+ } catch (error) {
+ log.warn("Failed to remove legacy Space home posts cache", error);
+ }
+};
+
+export const initializeSpaceHomePosts = async (
+ viewerSpaceId: string,
+ friends: FriendProfile[],
+) => {
+ const generation = cacheGeneration;
+ const key = await homePostsKey(viewerSpaceId);
+ if (!key || generation != cacheGeneration) return undefined;
+
+ const friendSpaceIds = friendSpaceIdsFrom(friends);
+ const friendSpaceIdSet = new Set(friendSpaceIds);
+ const result = await loadAllHomePosts(viewerSpaceId);
+ const latestPosts = latestPostsFor(result.items, friendSpaceIdSet);
+
+ const state = normalizedState({
+ friendSpaceIds,
+ latestPosts: [...latestPosts.values()],
+ readAheadPosts: [],
+ syncCursor: result.syncCursor,
+ unreadPosts: [],
+ version: homePostsVersion,
+ viewerSpaceId,
+ });
+ await enqueueCacheOperation(key, async () => {
+ if (generation != cacheGeneration) return;
+ await writeState(key, state);
+ if (generation != cacheGeneration) {
+ memoryCache.delete(key);
+ await removeKV(key);
+ }
+ });
+ if (generation != cacheGeneration) return undefined;
+ await removeLegacyState(viewerSpaceId);
+ return cloneState(state);
+};
+
+export const refreshSpaceHomePosts = async (
+ viewerSpaceId: string,
+ friends: FriendProfile[],
+) => {
+ const savedState = await loadSpaceHomePosts(viewerSpaceId);
+ if (!savedState) {
+ return initializeSpaceHomePosts(viewerSpaceId, friends);
+ }
+
+ const currentFriendSpaceIds = friendSpaceIdsFrom(friends);
+ const currentFriendSpaceIdSet = new Set(currentFriendSpaceIds);
+ const addedFriendSpaceIds = currentFriendSpaceIds.filter(
+ (spaceId) => !savedState.friendSpaceIds.includes(spaceId),
+ );
+ const addedFriendSpaceIdSet = new Set(addedFriendSpaceIds);
+ const savedMarker = markerFromCursor(savedState.syncCursor);
+ const result = await loadAllHomePosts(
+ viewerSpaceId,
+ refreshAfterCursor(savedState),
+ );
+ const latestPosts = latestPostsFor(result.items, currentFriendSpaceIdSet);
+ const returnedPostsByID = new Map(
+ result.items.map((post) => [post.postId, post]),
+ );
+ const discoveredPosts = savedMarker
+ ? result.items.filter((post) => isAfter(post, savedMarker))
+ : [];
+ const nextMarker = markerFromCursor(result.syncCursor);
+ return updateState(viewerSpaceId, (state) => {
+ const readAheadPostIds = new Set(
+ state.readAheadPosts.map((post) => post.postId),
+ );
+ const unreadPostsByID = new Map<number, SpacePost>();
+ for (const post of state.unreadPosts) {
+ const returnedPost = returnedPostsByID.get(post.postId);
+ if (
+ returnedPost &&
+ currentFriendSpaceIdSet.has(returnedPost.spaceId) &&
+ !returnedPost.isUnavailable
+ ) {
+ unreadPostsByID.set(returnedPost.postId, returnedPost);
+ }
+ }
+ for (const post of discoveredPosts) {
+ if (
+ currentFriendSpaceIdSet.has(post.spaceId) &&
+ !addedFriendSpaceIdSet.has(post.spaceId) &&
+ !post.isUnavailable &&
+ !readAheadPostIds.has(post.postId)
+ ) {
+ unreadPostsByID.set(post.postId, post);
+ }
+ }
+
+ return {
+ ...state,
+ friendSpaceIds: currentFriendSpaceIds,
+ latestPosts: [...latestPosts.values()],
+ readAheadPosts: nextMarker
+ ? state.readAheadPosts.filter((post) =>
+ isAfter(post, nextMarker),
+ )
+ : state.readAheadPosts,
+ syncCursor: result.syncCursor,
+ unreadPosts: [...unreadPostsByID.values()],
+ };
+ });
+};
+
+export const markSpaceHomePostRead = (
+ viewerSpaceId: string,
+ post: SpacePostMarker,
+) =>
+ updateState(viewerSpaceId, (state) => {
+ const syncMarker = markerFromCursor(state.syncCursor);
+ return {
+ ...state,
+ readAheadPosts:
+ syncMarker && !isAfter(post, syncMarker)
+ ? state.readAheadPosts
+ : [...state.readAheadPosts, markerFor(post)],
+ unreadPosts: state.unreadPosts.filter(
+ (item) => item.postId != post.postId,
+ ),
+ };
+ });
+
+export const patchCachedSpaceHomePost = (
+ viewerSpaceId: string,
+ postId: number,
+ patch: Partial<Pick<SpacePost, "caption" | "viewerLiked">>,
+) =>
+ updateState(viewerSpaceId, (state) => ({
+ ...state,
+ latestPosts: state.latestPosts.map((post) =>
+ post.postId == postId ? { ...post, ...patch } : post,
+ ),
+ unreadPosts: state.unreadPosts.map((post) =>
+ post.postId == postId ? { ...post, ...patch } : post,
+ ),
+ }));
+
+export const removeCachedSpaceHomePostsBySpace = (
+ viewerSpaceId: string,
+ removedSpaceId: string,
+) =>
+ updateState(viewerSpaceId, (state) => ({
+ ...state,
+ friendSpaceIds: state.friendSpaceIds.filter(
+ (spaceId) => spaceId != removedSpaceId,
+ ),
+ latestPosts: state.latestPosts.filter(
+ (post) => post.spaceId != removedSpaceId,
+ ),
+ unreadPosts: state.unreadPosts.filter(
+ (post) => post.spaceId != removedSpaceId,
+ ),
+ }));
+
+export const clearSpaceHomePostsMemoryCache = () => {
+ cacheGeneration += 1;
+ memoryCache.clear();
+};
diff --git a/web/apps/space/src/services/profile.ts b/web/apps/space/src/services/profile.ts
index dbc468d632..7e780b4887 100644
--- a/web/apps/space/src/services/profile.ts
+++ b/web/apps/space/src/services/profile.ts
@@ -372,7 +372,7 @@ export const loadExistingSpaceProfile = async (options?: {
const space = await loadExistingOwnedSpace();
if (!space) return null;
- // Give the home feed, which shares this lookup, the first request slot.
+ // Give the home screen, which shares this lookup, the first request slot.
await new Promise<void>((resolve) => setTimeout(resolve, 0));
const ctx = await ensureCurrentSpaceContext();
const spaceProfile = (await ctx.getSpaceProfile(
diff --git a/web/apps/space/src/services/space.ts b/web/apps/space/src/services/space.ts
index c364974463..f6d06a8c00 100644
--- a/web/apps/space/src/services/space.ts
+++ b/web/apps/space/src/services/space.ts
@@ -31,7 +31,7 @@ import { normalizeSpaceMessageText } from "utils/message-limits";
export { clearSpaceMediaURLCache } from "services/media-cache";
-const currentFeedPageSize = 10;
+const currentHomePostsPageSize = 100;
interface SpaceAvatar {
keyVersion: number;
@@ -90,6 +90,10 @@ interface SpacePostPageResponse {
nextCursor?: string;
}
+interface SpaceHomePostPageResponse extends SpacePostPageResponse {
+ syncCursor: string;
+}
+
type SpaceMessageConversationActivityType =
| "empty"
| "friend_request"
@@ -207,9 +211,10 @@ export interface SpacePost extends SpacePostBase {
imageUrl?: string;
}
-export interface SpacePostPage {
+export interface SpaceHomePostPage {
items: SpacePost[];
nextCursor?: string;
+ syncCursor: string;
}
export interface SpaceProfilePost extends SpacePostBase {
@@ -673,18 +678,22 @@ const profilePostFromPost = (post: SpacePostResponse): SpaceProfilePost => {
};
};
-const postPageFromAccountPage = async (
+const homePostPageFromAccountPage = async (
ctx: SpaceAccountCtxHandle,
- page: SpacePostPageResponse,
+ page: SpaceHomePostPageResponse,
loadMedia = true,
viewerSpaceId?: string,
-): Promise<SpacePostPage> => {
+): Promise<SpaceHomePostPage> => {
const items = await Promise.all(
(page.items ?? []).map((post) =>
postFromAccountPost(ctx, post, loadMedia, viewerSpaceId),
),
);
- return { items, nextCursor: page.nextCursor || undefined };
+ return {
+ items,
+ nextCursor: page.nextCursor || undefined,
+ syncCursor: page.syncCursor,
+ };
};
const profilePostPageFromPage = (
@@ -1162,19 +1171,21 @@ export const removeCurrentSpaceFriend = async (
}
};
-export const loadCurrentFeedPage = async (
+export const loadCurrentHomePostsPage = async (
spaceId: string,
+ after?: string,
cursor?: string,
-): Promise<SpacePostPage> => {
+): Promise<SpaceHomePostPage> => {
const ctx = await ensureCurrentSpaceContext();
try {
- const page = (await ctx.listFeed(
+ const page = (await ctx.listHomePosts(
spaceId,
+ after ?? null,
cursor ?? null,
- currentFeedPageSize,
- )) as SpacePostPageResponse;
+ currentHomePostsPageSize,
+ )) as SpaceHomePostPageResponse;
await persistCurrentOwnedSpaces(ctx);
- return await postPageFromAccountPage(ctx, page, false, spaceId);
+ return await homePostPageFromAccountPage(ctx, page, false, spaceId);
} finally {
releaseCurrentSpaceContext(ctx);
}
@@ -1214,25 +1225,6 @@ export const loadCurrentSpaceProfilePostsPage = async (
}
};
-export const loadCurrentSpaceLatestPost = async (
- spaceId: string,
- viewerSpaceId: string,
-): Promise<SpacePost | null> => {
- const ctx = await ensureCurrentSpaceContext();
- try {
- const page = (await ctx.listPosts(
- spaceId,
- viewerSpaceId,
- null,
- 1,
- )) as SpacePostPageResponse;
- const post = page.items?.[0];
- return post ? profilePostFromPost(post) : null;
- } finally {
- releaseCurrentSpaceContext(ctx);
- }
-};
-
export const loadCurrentSpacePost = async (
spaceId: string,
postId: number,
@@ -1361,9 +1353,6 @@ export const createCurrentPhotoPost = async ({
}
};
-export const isSpacePostLimitReachedError = (error: unknown) =>
- isNamedError(error, "post_limit_reached");
-
const normalizedImageDimension = (dimension: number | undefined) =>
typeof dimension == "number" && Number.isFinite(dimension) && dimension > 0
? Math.round(dimension)
diff --git a/web/apps/space/src/state/AppStateProvider.tsx b/web/apps/space/src/state/AppStateProvider.tsx
index 9c47e27c19..7d41f3544c 100644
--- a/web/apps/space/src/state/AppStateProvider.tsx
+++ b/web/apps/space/src/state/AppStateProvider.tsx
@@ -8,7 +8,7 @@ import React, {
} from "react";
import type { SpaceLoginCredentials } from "screens/LoginScreen";
import type { SetupProfile } from "screens/SetupProfileScreen";
-import { clearSpaceFeedMemoryCache } from "services/feed-cache";
+import { clearSpaceHomePostsMemoryCache } from "services/home-posts";
import type { PendingSpacePasskeyVerification } from "services/passkey-verification";
import { logoutRevokedSpaceSession } from "services/persistent-session";
import {
@@ -24,7 +24,6 @@ import {
clearSpaceMediaURLCache,
} from "services/space";
import {
- type LocalSpaceFeedPost,
type OnboardingEntrySource,
type PendingCreateProfile,
type RefreshSpaceProfileOptions,
@@ -40,9 +39,6 @@ export const SpaceAppStateProvider: React.FC<React.PropsWithChildren> = ({
const [friends, setFriends] = useState(initialFriends);
const [isLiveSignupVerification, setIsLiveSignupVerification] =
useState(false);
- const [localFeedPosts, setLocalFeedPosts] = useState<LocalSpaceFeedPost[]>(
- [],
- );
const [onboardingEntrySource, setOnboardingEntrySource] =
useState<OnboardingEntrySource>("direct");
const [pendingLoginCredentials, setPendingLoginCredentials] =
@@ -64,7 +60,6 @@ export const SpaceAppStateProvider: React.FC<React.PropsWithChildren> = ({
const [signupEmail, setSignupEmail] = useState("");
const avatarURLRef = useRef<string | null>(null);
const coverURLRef = useRef<string | null>(null);
- const localFeedPostURLRef = useRef<Set<string>>(new Set());
const profileRef = useRef<SetupProfile | null>(null);
const profileLoadGenerationRef = useRef(0);
@@ -221,7 +216,7 @@ export const SpaceAppStateProvider: React.FC<React.PropsWithChildren> = ({
profileLoadGenerationRef.current += 1;
clearCurrentSpaceContext();
clearSpaceFriendsCache();
- clearSpaceFeedMemoryCache();
+ clearSpaceHomePostsMemoryCache();
clearSpaceMediaURLCache();
applyProfile(null);
setProfileLoadError(undefined);
@@ -233,7 +228,6 @@ export const SpaceAppStateProvider: React.FC<React.PropsWithChildren> = ({
setPendingProfileCoverFile(null);
setPendingCreateProfile(null);
setOnboardingEntrySource("direct");
- setLocalFeedPosts([]);
setFriends(initialFriends());
}, [applyProfile]);
@@ -241,42 +235,10 @@ export const SpaceAppStateProvider: React.FC<React.PropsWithChildren> = ({
void refreshProfile();
}, [refreshProfile]);
- useEffect(() => {
- const nextURLs = new Set(
- localFeedPosts
- .filter(
- (
- post,
- ): post is Extract<
- LocalSpaceFeedPost,
- { status: "failed" | "pending" }
- > => post.status == "pending" || post.status == "failed",
- )
- .map((post) => post.imageUrl)
- .filter((url) => url.startsWith("blob:")),
- );
-
- for (const url of localFeedPostURLRef.current) {
- if (!nextURLs.has(url)) URL.revokeObjectURL(url);
- }
- localFeedPostURLRef.current = nextURLs;
- }, [localFeedPosts]);
-
- useEffect(
- () => () => {
- for (const url of localFeedPostURLRef.current) {
- URL.revokeObjectURL(url);
- }
- localFeedPostURLRef.current.clear();
- },
- [],
- );
-
const value = useMemo<SpaceAppState>(
() => ({
friends,
isLiveSignupVerification,
- localFeedPosts,
onboardingEntrySource,
pendingLoginCredentials,
pendingPasskeyVerification,
@@ -291,7 +253,6 @@ export const SpaceAppStateProvider: React.FC<React.PropsWithChildren> = ({
resetAfterLogout,
setFriends,
setIsLiveSignupVerification,
- setLocalFeedPosts,
setOnboardingEntrySource,
setPendingLoginCredentials,
setPendingPasskeyVerification,
@@ -306,7 +267,6 @@ export const SpaceAppStateProvider: React.FC<React.PropsWithChildren> = ({
[
friends,
isLiveSignupVerification,
- localFeedPosts,
onboardingEntrySource,
pendingLoginCredentials,
pendingPasskeyVerification,
diff --git a/web/apps/space/src/state/app-state.tsx b/web/apps/space/src/state/app-state.tsx
index 9e6d5c57b7..b4f3a4c24e 100644
--- a/web/apps/space/src/state/app-state.tsx
+++ b/web/apps/space/src/state/app-state.tsx
@@ -6,7 +6,6 @@ import type {
SetupProfileDetails,
} from "screens/SetupProfileScreen";
import type { PendingSpacePasskeyVerification } from "services/passkey-verification";
-import type { SpacePost } from "services/space";
import type { CreateProfileSource } from "utils/routes";
export type OnboardingEntrySource = "direct" | "add-friend-link";
@@ -19,47 +18,9 @@ export interface RefreshSpaceProfileOptions {
throwOnError?: boolean;
}
-export interface PendingSpaceFeedPost {
- avatarUrl?: string | null;
- caption?: string;
- friendID: string;
- height?: number;
- id: string;
- imageUrl: string;
- name: string;
- spaceId: string;
- status: "pending";
- timestampMs: number;
- width?: number;
-}
-
-export type FailedSpaceFeedPost = Omit<PendingSpaceFeedPost, "status"> & {
- reason?: "post-limit";
- status: "failed";
-};
-
-export interface PostedSpaceFeedPost {
- id: string;
- post: SpacePost;
- status: "posted";
-}
-
-export interface ReadySpaceFeedPost {
- id: string;
- post: SpacePost;
- status: "ready";
-}
-
-export type LocalSpaceFeedPost =
- | FailedSpaceFeedPost
- | PendingSpaceFeedPost
- | PostedSpaceFeedPost
- | ReadySpaceFeedPost;
-
export interface SpaceAppState {
friends: FriendProfile[];
isLiveSignupVerification: boolean;
- localFeedPosts: LocalSpaceFeedPost[];
onboardingEntrySource: OnboardingEntrySource;
pendingLoginCredentials: SpaceLoginCredentials | null;
pendingPasskeyVerification: PendingSpacePasskeyVerification | null;
@@ -77,9 +38,6 @@ export interface SpaceAppState {
resetAfterLogout: () => void;
setFriends: React.Dispatch<React.SetStateAction<FriendProfile[]>>;
setIsLiveSignupVerification: React.Dispatch<React.SetStateAction<boolean>>;
- setLocalFeedPosts: React.Dispatch<
- React.SetStateAction<LocalSpaceFeedPost[]>
- >;
setOnboardingEntrySource: React.Dispatch<
React.SetStateAction<OnboardingEntrySource>
>;
diff --git a/web/apps/space/src/utils/home-circle-layout.ts b/web/apps/space/src/utils/home-circle-layout.ts
index afc9d980c7..071892643e 100644
--- a/web/apps/space/src/utils/home-circle-layout.ts
+++ b/web/apps/space/src/utils/home-circle-layout.ts
@@ -3,12 +3,25 @@ interface CircleSlot {
row: number;
}
+const gridFriendCountStart = 9;
+const gridColumnCount = 3;
+const circleGapRatio = 0.1;
+
+export const usesHomeCircleGrid = (count: number) =>
+ count >= gridFriendCountStart;
+
export interface HomeCirclePlacement {
size: number;
x: number;
y: number;
}
+export interface HomeCircleGridLayout {
+ gap: number;
+ rows: number;
+ size: number;
+}
+
const circleSlotsForCount = (count: number) => {
if (count == 1) {
return { columns: 1, rows: 1, slots: [{ column: 0, row: 0 }] };
@@ -25,12 +38,12 @@ const circleSlotsForCount = (count: number) => {
}
if (count == 3) {
return {
- columns: 2,
- rows: 2,
+ columns: 1,
+ rows: 3,
slots: [
- { column: 0.5, row: 0 },
+ { column: 0, row: 0 },
{ column: 0, row: 1 },
- { column: 1, row: 1 },
+ { column: 0, row: 2 },
],
};
}
@@ -49,33 +62,56 @@ const circleSlotsForCount = (count: number) => {
return { columns, rows, slots };
};
+const layoutDimensions = (columns: number, rows: number) => ({
+ height: rows + (rows - 1) * circleGapRatio,
+ width: columns + (columns - 1) * circleGapRatio,
+});
+
+export const homeCircleGridLayout = (
+ count: number,
+ canvasWidth: number,
+ canvasHeight: number,
+): HomeCircleGridLayout | undefined => {
+ if (!usesHomeCircleGrid(count) || canvasWidth <= 0 || canvasHeight <= 0) {
+ return undefined;
+ }
+
+ const rows = Math.ceil(count / gridColumnCount);
+ const layout = layoutDimensions(gridColumnCount, rows);
+ const size = Math.min(
+ canvasWidth / layout.width,
+ canvasHeight / layout.height,
+ );
+ return { gap: size * circleGapRatio, rows, size };
+};
+
export const homeCirclePlacements = (
count: number,
canvasWidth: number,
canvasHeight: number,
): HomeCirclePlacement[] => {
- if (count < 1 || canvasWidth <= 0 || canvasHeight <= 0) return [];
+ if (
+ count < 1 ||
+ usesHomeCircleGrid(count) ||
+ canvasWidth <= 0 ||
+ canvasHeight <= 0
+ ) {
+ return [];
+ }
const { columns, rows, slots } = circleSlotsForCount(count);
- const circleGapRatio = 0.1;
- const slotsByRow = Array.from({ length: rows }, (_, row) =>
- slots.filter((slot) => slot.row == row),
- );
const rowOffsets = [0];
for (let row = 1; row < rows; row++) {
- const rowsAreStaggered =
- slotsByRow[row - 1]!.length != slotsByRow[row]!.length;
- rowOffsets.push(rowOffsets[row - 1]! + (rowsAreStaggered ? 1 : 1.1));
+ rowOffsets.push(rowOffsets[row - 1]! + 1.1);
}
- const layoutWidth = columns + (columns - 1) * circleGapRatio;
- const layoutHeight = 1 + rowOffsets[rowOffsets.length - 1]!;
+ const layout = layoutDimensions(columns, rows);
const size = Math.min(
- canvasWidth / layoutWidth,
- canvasHeight / layoutHeight,
+ canvasWidth / layout.width,
+ canvasHeight / layout.height,
);
const horizontalStep = size * (1 + circleGapRatio);
const renderedWidth = size + horizontalStep * (columns - 1);
- const renderedHeight = size * layoutHeight;
+ const renderedHeight = size * layout.height;
const originX = (canvasWidth - renderedWidth) / 2;
const originY = (canvasHeight - renderedHeight) / 2;
return slots.map(({ column, row }) => ({
diff --git a/web/apps/space/src/utils/local-feed-post.ts b/web/apps/space/src/utils/local-feed-post.ts
deleted file mode 100644
index 0a2d16e141..0000000000
--- a/web/apps/space/src/utils/local-feed-post.ts
+++ /dev/null
@@ -1,52 +0,0 @@
-import type React from "react";
-import type { SpacePost } from "services/space";
-import type { FailedSpaceFeedPost, LocalSpaceFeedPost } from "state/app-state";
-
-let nextLocalFeedPostID = 0;
-
-const postedConfirmationDurationMs = 1500;
-
-export const createLocalFeedPostID = () =>
- `space-local-post-${Date.now()}-${nextLocalFeedPostID++}`;
-
-export const confirmLocalFeedPost = (
- setLocalFeedPosts: React.Dispatch<
- React.SetStateAction<LocalSpaceFeedPost[]>
- >,
- localPostId: string,
- post: SpacePost,
-) => {
- setLocalFeedPosts((currentPosts) =>
- currentPosts.map((item) =>
- item.id == localPostId
- ? { id: localPostId, post, status: "posted" }
- : item,
- ),
- );
-
- window.setTimeout(() => {
- setLocalFeedPosts((currentPosts) =>
- currentPosts.map((item) =>
- item.id == localPostId && item.status == "posted"
- ? { id: localPostId, post: item.post, status: "ready" }
- : item,
- ),
- );
- }, postedConfirmationDurationMs);
-};
-
-export const failLocalFeedPost = (
- setLocalFeedPosts: React.Dispatch<
- React.SetStateAction<LocalSpaceFeedPost[]>
- >,
- localPostId: string,
- reason?: FailedSpaceFeedPost["reason"],
-) => {
- setLocalFeedPosts((currentPosts) =>
- currentPosts.map((item) =>
- item.id == localPostId && item.status == "pending"
- ? { ...item, reason, status: "failed" }
- : item,
- ),
- );
-};