silberengel
/
jumble
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

bug-fixes

imwald
Silberengel 1 month ago
parent
ec17e4d2ad
commit
5ae672ba72
13 changed files with 563 additions and 280 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 148
      src/PageManager.tsx
  2. 11
      src/components/NoteList/index.tsx
  3. 6
      src/components/SimpleNoteFeed/index.tsx
  4. 22
      src/constants.ts
  5. 14
      src/hooks/useFetchCalendarRsvps.tsx
  6. 32
      src/hooks/useFetchProfile.tsx
  7. 10
      src/lib/spell-list-import.ts
  8. 56
      src/pages/primary/DiscussionsPage/index.tsx
  9. 121
      src/routes.tsx
  10. 52
      src/services/client-query.service.ts
  11. 143
      src/services/client-replaceable-events.service.ts
  12. 211
      src/services/client.service.ts
  13. 17
      src/services/navigation.service.ts

148
src/PageManager.tsx
Unescape View File

@ -1,11 +1,8 @@
import Sidebar from '@/components/Sidebar'
import { Button } from '@/components/ui/button' import { Button } from '@/components/ui/button'
import { cn } from '@/lib/utils' import { cn } from '@/lib/utils'
import logger from '@/lib/logger' import logger from '@/lib/logger'
import { ChevronLeft } from 'lucide-react' import { ChevronLeft } from 'lucide-react'
import { NavigationService } from '@/services/navigation.service' import { NavigationService } from '@/services/navigation.service'
import NoteListPage from '@/pages/primary/NoteListPage'
import SecondaryNoteListPage from '@/pages/secondary/NoteListPage'
// Page imports needed for primary note view // Page imports needed for primary note view
import NoteDrawer from '@/components/NoteDrawer' import NoteDrawer from '@/components/NoteDrawer'
import SecondaryProfilePage from '@/pages/secondary/ProfilePage' import SecondaryProfilePage from '@/pages/secondary/ProfilePage'
@ -28,6 +25,7 @@ import {
createRef, createRef,
isValidElement, isValidElement,
lazy, lazy,
type ReactElement,
type ReactNode, type ReactNode,
RefObject, RefObject,
Suspense, Suspense,
@ -38,26 +36,39 @@ import {
useRef, useRef,
useState useState
} from 'react' } from 'react'
import BottomNavigationBar from './components/BottomNavigationBar'
import { useTranslation } from 'react-i18next' import { useTranslation } from 'react-i18next'
import TooManyRelaysAlertDialog from './components/TooManyRelaysAlertDialog' import { KeyboardShortcutsHelpProvider } from '@/components/KeyboardShortcutsHelp'
import { normalizeUrl } from './lib/url' import { normalizeUrl } from './lib/url'
import ExplorePage from './pages/primary/ExplorePage' import modalManager from './services/modal-manager.service'
import MePage from './pages/primary/MePage' import { routes } from './routes'
import ProfilePage from './pages/primary/ProfilePage'
import RelayPage from './pages/primary/RelayPage'
import SearchPage from './pages/primary/SearchPage'
import RssPage from './pages/primary/RssPage'
import SettingsPrimaryPage from './pages/primary/SettingsPrimaryPage'
import { useScreenSize } from './providers/ScreenSizeProvider' import { useScreenSize } from './providers/ScreenSizeProvider'
/** Lazy-loaded so PageManager does not synchronously import SpellsPage (avoids HMR cycle: SpellsPage → PrimaryPageLayout → PageManager → SpellsPage). */ /** Lazy-loaded so PageManager does not synchronously import SpellsPage (avoids HMR cycle: SpellsPage → PrimaryPageLayout → PageManager → SpellsPage). */
const SpellsPageLazy = lazy(() => import('./pages/primary/SpellsPage')) const SpellsPageLazy = lazy(() => import('./pages/primary/SpellsPage'))
import { routes } from './routes' /** Lazy NoteList pages break: PageManager → … → NoteList → NoteCard → useSmartNoteNavigation → PageManager */
import modalManager from './services/modal-manager.service' const NoteListPageLazy = lazy(() => import('@/pages/primary/NoteListPage'))
import CreateWalletGuideToast from './components/CreateWalletGuideToast' const SecondaryNoteListPageLazy = lazy(() => import('@/pages/secondary/NoteListPage'))
import { KeyboardShortcutsHelpProvider } from '@/components/KeyboardShortcutsHelp'
const primaryPageLazyFallback = (
<div className="flex flex-1 items-center justify-center p-8 text-sm text-muted-foreground">
Loading…
</div>
)
/** Lazy primary pages: each may import PrimaryPageLayout → usePrimaryPage → would sync-import PageManager. */
const ExplorePageLazy = lazy(() => import('./pages/primary/ExplorePage'))
const MePageLazy = lazy(() => import('./pages/primary/MePage'))
const ProfilePageLazy = lazy(() => import('./pages/primary/ProfilePage'))
const RelayPageLazy = lazy(() => import('./pages/primary/RelayPage'))
const SearchPageLazy = lazy(() => import('./pages/primary/SearchPage'))
const RssPageLazy = lazy(() => import('./pages/primary/RssPage'))
const SettingsPrimaryPageLazy = lazy(() => import('./pages/primary/SettingsPrimaryPage'))
/** Lazy chrome: Sidebar / bottom bar / dialogs import hooks from PageManager — must not be sync-imported here. */
const SidebarLazy = lazy(() => import('@/components/Sidebar'))
const BottomNavigationBarLazy = lazy(() => import('@/components/BottomNavigationBar'))
const TooManyRelaysAlertDialogLazy = lazy(() => import('@/components/TooManyRelaysAlertDialog'))
const CreateWalletGuideToastLazy = lazy(() => import('@/components/CreateWalletGuideToast'))
type TPrimaryPageContext = { type TPrimaryPageContext = {
navigate: (page: TPrimaryPageName, props?: object) => void navigate: (page: TPrimaryPageName, props?: object) => void
@ -96,22 +107,48 @@ const PRIMARY_PAGE_REF_MAP = {
// Lazy function to create PRIMARY_PAGE_MAP to avoid circular dependency // Lazy function to create PRIMARY_PAGE_MAP to avoid circular dependency
// This is only evaluated when called, not at module load time // This is only evaluated when called, not at module load time
const getPrimaryPageMap = () => ({ const getPrimaryPageMap = () => ({
home: <ExplorePage ref={PRIMARY_PAGE_REF_MAP.home} />, home: (
feed: <NoteListPage ref={PRIMARY_PAGE_REF_MAP.feed} />, <Suspense fallback={primaryPageLazyFallback}>
me: <MePage ref={PRIMARY_PAGE_REF_MAP.me} />, <ExplorePageLazy ref={PRIMARY_PAGE_REF_MAP.home} />
profile: <ProfilePage ref={PRIMARY_PAGE_REF_MAP.profile} />, </Suspense>
relay: <RelayPage ref={PRIMARY_PAGE_REF_MAP.relay} />, ),
search: <SearchPage ref={PRIMARY_PAGE_REF_MAP.search} />, feed: (
rss: <RssPage ref={PRIMARY_PAGE_REF_MAP.rss} />, <Suspense fallback={primaryPageLazyFallback}>
settings: <SettingsPrimaryPage ref={PRIMARY_PAGE_REF_MAP.settings} />, <NoteListPageLazy ref={PRIMARY_PAGE_REF_MAP.feed} />
</Suspense>
),
me: (
<Suspense fallback={primaryPageLazyFallback}>
<MePageLazy ref={PRIMARY_PAGE_REF_MAP.me} />
</Suspense>
),
profile: (
<Suspense fallback={primaryPageLazyFallback}>
<ProfilePageLazy ref={PRIMARY_PAGE_REF_MAP.profile} />
</Suspense>
),
relay: (
<Suspense fallback={primaryPageLazyFallback}>
<RelayPageLazy ref={PRIMARY_PAGE_REF_MAP.relay} />
</Suspense>
),
search: (
<Suspense fallback={primaryPageLazyFallback}>
<SearchPageLazy ref={PRIMARY_PAGE_REF_MAP.search} />
</Suspense>
),
rss: (
<Suspense fallback={primaryPageLazyFallback}>
<RssPageLazy ref={PRIMARY_PAGE_REF_MAP.rss} />
</Suspense>
),
settings: (
<Suspense fallback={primaryPageLazyFallback}>
<SettingsPrimaryPageLazy ref={PRIMARY_PAGE_REF_MAP.settings} />
</Suspense>
),
spells: ( spells: (
<Suspense <Suspense fallback={primaryPageLazyFallback}>
fallback={
<div className="flex flex-1 items-center justify-center p-8 text-sm text-muted-foreground">
Loading…
</div>
}
>
<SpellsPageLazy ref={PRIMARY_PAGE_REF_MAP.spells} /> <SpellsPageLazy ref={PRIMARY_PAGE_REF_MAP.spells} />
</Suspense> </Suspense>
) )
@ -443,7 +480,12 @@ export function useSmartHashtagNavigation() {
// Use a key based on the hashtag and navigation counter to force remounting when hashtag changes // Use a key based on the hashtag and navigation counter to force remounting when hashtag changes
// This ensures the component reads the new URL parameters when it mounts // This ensures the component reads the new URL parameters when it mounts
// setPrimaryNoteView will increment the counter, so we use counter + 1 for the key // setPrimaryNoteView will increment the counter, so we use counter + 1 for the key
setPrimaryNoteView(<SecondaryNoteListPage key={key} hideTitlebar={true} />, 'hashtag') setPrimaryNoteView(
<Suspense fallback={primaryPageLazyFallback}>
<SecondaryNoteListPageLazy key={key} hideTitlebar={true} />
</Suspense>,
'hashtag'
)
// Dispatch custom event as a fallback for components that might be reused // Dispatch custom event as a fallback for components that might be reused
window.dispatchEvent(new CustomEvent('hashtag-navigation', { detail: { url: parsedUrl } })) window.dispatchEvent(new CustomEvent('hashtag-navigation', { detail: { url: parsedUrl } }))
} }
@ -1520,9 +1562,15 @@ export function PageManager({ maxStackSize = 5 }: { maxStackSize?: number }) {
noteId={drawerNoteId} noteId={drawerNoteId}
/> />
)} )}
<BottomNavigationBar /> <Suspense fallback={null}>
<TooManyRelaysAlertDialog /> <BottomNavigationBarLazy />
<CreateWalletGuideToast /> </Suspense>
<Suspense fallback={null}>
<TooManyRelaysAlertDialogLazy />
</Suspense>
<Suspense fallback={null}>
<CreateWalletGuideToastLazy />
</Suspense>
</NoteDrawerContext.Provider> </NoteDrawerContext.Provider>
</PrimaryNoteViewContext.Provider> </PrimaryNoteViewContext.Provider>
</NotificationProvider> </NotificationProvider>
@ -1562,7 +1610,9 @@ export function PageManager({ maxStackSize = 5 }: { maxStackSize?: number }) {
maxWidth: '1920px' maxWidth: '1920px'
}} }}
> >
<Sidebar /> <Suspense fallback={null}>
<SidebarLazy />
</Suspense>
{(() => { {(() => {
if (panelMode === 'double') { if (panelMode === 'double') {
// Double-pane mode: show feed on left (flexible, maintains width), secondary stack on right (1042px, same as drawer) // Double-pane mode: show feed on left (flexible, maintains width), secondary stack on right (1042px, same as drawer)
@ -1667,8 +1717,12 @@ export function PageManager({ maxStackSize = 5 }: { maxStackSize?: number }) {
</SheetContent> </SheetContent>
</Sheet> </Sheet>
)} )}
<TooManyRelaysAlertDialog /> <Suspense fallback={null}>
<CreateWalletGuideToast /> <TooManyRelaysAlertDialogLazy />
</Suspense>
<Suspense fallback={null}>
<CreateWalletGuideToastLazy />
</Suspense>
</NoteDrawerContext.Provider> </NoteDrawerContext.Provider>
</PrimaryNoteViewContext.Provider> </PrimaryNoteViewContext.Provider>
</NotificationProvider> </NotificationProvider>
@ -1715,6 +1769,20 @@ function isCurrentPage(stack: TStackItem[], url: string) {
return currentPage.url === url return currentPage.url === url
} }
/** Route elements are `<Suspense><LazyPage /></Suspense>` — props must be applied to the lazy leaf, not Suspense. */
function cloneSecondaryRouteElement(
element: ReactElement,
props: Record<string, unknown>
): ReactElement {
if (element.type === Suspense) {
const inner = element.props.children
if (isValidElement(inner)) {
return cloneElement(element, undefined, cloneElement(inner, props as any))
}
}
return cloneElement(element, props as any)
}
function findAndCreateComponent(url: string, index: number) { function findAndCreateComponent(url: string, index: number) {
const path = url.split('?')[0].split('#')[0] const path = url.split('?')[0].split('#')[0]
logger.component('PageManager', 'findAndCreateComponent called', { url, path, routes: routes.length }) logger.component('PageManager', 'findAndCreateComponent called', { url, path, routes: routes.length })
@ -1739,7 +1807,7 @@ function findAndCreateComponent(url: string, index: number) {
logger.component('PageManager', 'Creating component with params', { params, index }) logger.component('PageManager', 'Creating component with params', { params, index })
try { try {
const component = cloneElement(element, { ...params, index, ref } as any) const component = cloneSecondaryRouteElement(element, { ...params, index, ref })
logger.component('PageManager', 'Component created successfully', { hasComponent: !!component }) logger.component('PageManager', 'Component created successfully', { hasComponent: !!component })
return { component, ref } return { component, ref }
} catch (error) { } catch (error) {

11
src/components/NoteList/index.tsx
Unescape View File

@ -161,6 +161,11 @@ const NoteList = forwardRef(
] ]
) )
const shouldHideEventRef = useRef(shouldHideEvent)
useEffect(() => {
shouldHideEventRef.current = shouldHideEvent
}, [shouldHideEvent])
const filteredEvents = useMemo(() => { const filteredEvents = useMemo(() => {
const idSet = new Set<string>() const idSet = new Set<string>()
@ -292,6 +297,8 @@ const NoteList = forwardRef(
onEvents: (events: Event[], eosed: boolean) => { onEvents: (events: Event[], eosed: boolean) => {
if (events.length > 0) { if (events.length > 0) {
setEvents(events) setEvents(events)
// Do not wait for full EOSE across many relays — otherwise loading/skeleton stays up for 10–30s+
setLoading(false)
// CRITICAL: Prefetch profiles for initial events (optimized for faster initial load) // CRITICAL: Prefetch profiles for initial events (optimized for faster initial load)
// Only prefetch for first 50 events to reduce initial load time // Only prefetch for first 50 events to reduce initial load time
@ -369,7 +376,7 @@ const NoteList = forwardRef(
if (!isReply && !showKind1OPs) return if (!isReply && !showKind1OPs) return
} }
if (event.kind === ExtendedKind.COMMENT && !showKind1111) return if (event.kind === ExtendedKind.COMMENT && !showKind1111) return
if (shouldHideEvent(event)) return if (shouldHideEventRef.current(event)) return
if (pubkey && event.pubkey === pubkey) { if (pubkey && event.pubkey === pubkey) {
// If the new event is from the current user, insert it directly into the feed // If the new event is from the current user, insert it directly into the feed
setEvents((oldEvents) => setEvents((oldEvents) =>
@ -414,7 +421,7 @@ const NoteList = forwardRef(
showKind1Replies, showKind1Replies,
showKind1111, showKind1111,
useFilterAsIs, useFilterAsIs,
shouldHideEvent areAlgoRelays
]) ])
// Use refs to avoid dependency issues and ensure latest values in async callbacks // Use refs to avoid dependency issues and ensure latest values in async callbacks

6
src/components/SimpleNoteFeed/index.tsx
Unescape View File

@ -3,7 +3,7 @@ import { useTranslation } from 'react-i18next'
import { RefreshCw } from 'lucide-react' import { RefreshCw } from 'lucide-react'
import { useNostr } from '@/providers/NostrProvider' import { useNostr } from '@/providers/NostrProvider'
import { normalizeUrl } from '@/lib/url' import { normalizeUrl } from '@/lib/url'
import { FAST_READ_RELAY_URLS } from '@/constants' import { FAST_READ_RELAY_URLS, FIRST_RELAY_RESULT_GRACE_MS } from '@/constants'
import client from '@/services/client.service' import client from '@/services/client.service'
import { Event } from 'nostr-tools' import { Event } from 'nostr-tools'
import { kinds } from 'nostr-tools' import { kinds } from 'nostr-tools'
@ -87,7 +87,9 @@ const SimpleNoteFeed = forwardRef<
// Fetch events // Fetch events
logger.component('SimpleNoteFeed', 'Calling client.fetchEvents') logger.component('SimpleNoteFeed', 'Calling client.fetchEvents')
const { queryService } = await import('@/services/client.service') const { queryService } = await import('@/services/client.service')
const fetchedEvents = await queryService.fetchEvents(allRelays, [filter]) const fetchedEvents = await queryService.fetchEvents(allRelays, [filter], {
firstRelayResultGraceMs: FIRST_RELAY_RESULT_GRACE_MS
})
logger.component('SimpleNoteFeed', 'Fetched events', { count: fetchedEvents.length }) logger.component('SimpleNoteFeed', 'Fetched events', { count: fetchedEvents.length })

22
src/constants.ts
Unescape View File

@ -14,6 +14,28 @@ export const DEFAULT_FAVORITE_RELAYS = [
'wss://nostr.land' 'wss://nostr.land'
] ]
/** Multi-relay queries and timeline initial REQ: after the first event, wait this long then close (query) or finalize EOSE (live feed) while keeping the subscription open for new events. */
export const FIRST_RELAY_RESULT_GRACE_MS = 2000
/**
* Implicit query feed grace ({@link FIRST_RELAY_RESULT_GRACE_MS}) applies only when the largest `limit` among
* filters is at least this value. Omitting `limit` counts as 0 (no implicit grace).
*/
export const FEED_FIRST_RELAY_RESULT_GRACE_MIN_LIMIT = 200
/**
* Batched kind-0 queries (ReplaceableEventService) over many relays (inbox, favorites, cache, defaults).
* Too low causes empty profiles and NIP-05 gaps when relays are slow or many URLs are queried.
*/
export const METADATA_BATCH_QUERY_GLOBAL_TIMEOUT_MS = 16000
export const METADATA_BATCH_QUERY_EOSE_TIMEOUT_MS = 500
/**
* useFetchProfile: outer Promise.race on fetchProfileEvent and wait-for-shared-promise timeouts.
* Must be greater than {@link METADATA_BATCH_QUERY_GLOBAL_TIMEOUT_MS} so the batch can finish first.
*/
export const PROFILE_FETCH_PROMISE_TIMEOUT_MS = 20000
export const RECOMMENDED_RELAYS = DEFAULT_FAVORITE_RELAYS.concat([]) export const RECOMMENDED_RELAYS = DEFAULT_FAVORITE_RELAYS.concat([])
export const RECOMMENDED_BLOSSOM_SERVERS = [ export const RECOMMENDED_BLOSSOM_SERVERS = [

14
src/hooks/useFetchCalendarRsvps.tsx
Unescape View File

@ -65,11 +65,15 @@ export function useFetchCalendarRsvps(calendarEvent: Event | undefined) {
.then((relayUrls: string[] | undefined) => { .then((relayUrls: string[] | undefined) => {
if (cancelled) return if (cancelled) return
const urls = relayUrls?.length ? relayUrls : Array.from(baseUrls) const urls = relayUrls?.length ? relayUrls : Array.from(baseUrls)
return queryService.fetchEvents(urls, { return queryService.fetchEvents(
kinds: [ExtendedKind.CALENDAR_EVENT_RSVP], urls,
'#a': [coordinate], {
limit: 200 kinds: [ExtendedKind.CALENDAR_EVENT_RSVP],
}) '#a': [coordinate],
limit: 200
},
{ firstRelayResultGraceMs: false }
)
}) })
.then((events) => { .then((events) => {
if (cancelled) return if (cancelled) return

32
src/hooks/useFetchProfile.tsx
Unescape View File

@ -1,3 +1,4 @@
import { PROFILE_FETCH_PROMISE_TIMEOUT_MS } from '@/constants'
import { getProfileFromEvent } from '@/lib/event-metadata' import { getProfileFromEvent } from '@/lib/event-metadata'
import { userIdToPubkey } from '@/lib/pubkey' import { userIdToPubkey } from '@/lib/pubkey'
import { useNostr } from '@/providers/NostrProvider' import { useNostr } from '@/providers/NostrProvider'
@ -79,7 +80,7 @@ export function useFetchProfile(id?: string, skipCache = false) {
pubkey: pubkey.substring(0, 8) pubkey: pubkey.substring(0, 8)
}) })
resolve(null) resolve(null)
}, 5000) // 5 seconds }, PROFILE_FETCH_PROMISE_TIMEOUT_MS)
}) })
const existingProfile = await Promise.race([existingPromise, timeoutPromise]) const existingProfile = await Promise.race([existingPromise, timeoutPromise])
@ -135,8 +136,8 @@ export function useFetchProfile(id?: string, skipCache = false) {
logger.warn('[useFetchProfile] Retry promise timeout, not starting duplicate fetch', { logger.warn('[useFetchProfile] Retry promise timeout, not starting duplicate fetch', {
pubkey: pubkey.substring(0, 8) pubkey: pubkey.substring(0, 8)
}) })
resolve(null) resolve(null)
}, 5000) // 5 seconds }, PROFILE_FETCH_PROMISE_TIMEOUT_MS)
}) })
const retryProfile = await Promise.race([retryPromise, timeoutPromise]) const retryProfile = await Promise.race([retryPromise, timeoutPromise])
@ -183,12 +184,15 @@ export function useFetchProfile(id?: string, skipCache = false) {
globalFetchingPubkeys.add(pubkey) globalFetchingPubkeys.add(pubkey)
const startTime = Date.now() const startTime = Date.now()
// CRITICAL: Add timeout to prevent infinite hangs // CRITICAL: Add timeout to prevent infinite hangs (must exceed batched metadata query globalTimeout)
// Use Promise.race to timeout after 5 seconds
const timeoutPromise = new Promise<never>((_, reject) => { const timeoutPromise = new Promise<never>((_, reject) => {
setTimeout(() => { setTimeout(() => {
reject(new Error(`Profile fetch timeout after 5s for pubkey ${pubkey.substring(0, 8)}`)) reject(
}, 5000) // 5 second timeout new Error(
`Profile fetch timeout after ${PROFILE_FETCH_PROMISE_TIMEOUT_MS}ms for pubkey ${pubkey.substring(0, 8)}`
)
)
}, PROFILE_FETCH_PROMISE_TIMEOUT_MS)
}) })
// Use fetchProfileEvent which includes author's relay list for better profile discovery // Use fetchProfileEvent which includes author's relay list for better profile discovery
@ -207,12 +211,7 @@ export function useFetchProfile(id?: string, skipCache = false) {
fetchTime: `${fetchTime}ms` fetchTime: `${fetchTime}ms`
}) })
} }
if (cancelled.current) {
logger.info('[useFetchProfile] Fetch cancelled after fetch', { pubkey })
return null
}
if (profileEvent) { if (profileEvent) {
// getProfileFromEvent always returns a profile object (with fallback username) // getProfileFromEvent always returns a profile object (with fallback username)
const newProfile = getProfileFromEvent(profileEvent) const newProfile = getProfileFromEvent(profileEvent)
@ -221,8 +220,13 @@ export function useFetchProfile(id?: string, skipCache = false) {
pubkey: pubkey.substring(0, 8), pubkey: pubkey.substring(0, 8),
username: newProfile.username, username: newProfile.username,
hasAvatar: !!newProfile.avatar, hasAvatar: !!newProfile.avatar,
fetchTime: `${fetchTime}ms` fetchTime: `${fetchTime}ms`,
unmounted: cancelled.current
}) })
// CRITICAL: Always return the profile from this shared promise, even when the
// originating hook cleaned up (list virtualization, Strict Mode, feed switch).
// Returning null here made every waiter treat the result like a timeout, applied
// cooldowns, and left avatars empty (especially busy feeds e.g. all-favorites).
return newProfile return newProfile
} }
// Only log warnings for missing profiles if skipCache is true (user explicitly requested) // Only log warnings for missing profiles if skipCache is true (user explicitly requested)

10
src/lib/spell-list-import.ts
Unescape View File

@ -180,8 +180,14 @@ export async function resolveSpellListATags(
try { try {
const events = const events =
relays.length > 0 relays.length > 0
? await queryService.fetchEvents(relays, filter, { globalTimeout: 12_000 }) ? await queryService.fetchEvents(relays, filter, {
: await queryService.fetchEvents([], filter, { globalTimeout: 12_000 }) globalTimeout: 12_000,
firstRelayResultGraceMs: false
})
: await queryService.fetchEvents([], filter, {
globalTimeout: 12_000,
firstRelayResultGraceMs: false
})
if (!events.length) { if (!events.length) {
notices.push(`listImportATagNotFound:${at.slice(0, 48)}`) notices.push(`listImportATagNotFound:${at.slice(0, 48)}`)
return return

56
src/pages/primary/DiscussionsPage/index.tsx
Unescape View File

@ -422,12 +422,16 @@ const DiscussionsPage = forwardRef<TPageRef, { embedded?: boolean }>(function Di
logger.debug('[DiscussionsPage] Using relays:', allRelays.slice(0, 10), '... (total:', allRelays.length, ')') logger.debug('[DiscussionsPage] Using relays:', allRelays.slice(0, 10), '... (total:', allRelays.length, ')')
// Step 1: Fetch all discussion threads (kind 11) // Step 1: Fetch all discussion threads (kind 11)
const discussionThreads = await queryService.fetchEvents(allRelays, [ const discussionThreads = await queryService.fetchEvents(
{ allRelays,
kinds: [11], // ExtendedKind.DISCUSSION [
limit: 500 // Increased from 100 to load more threads per request {
} kinds: [11], // ExtendedKind.DISCUSSION
]) limit: 500 // Increased from 100 to load more threads per request
}
],
{ firstRelayResultGraceMs: false }
)
logger.debug('[DiscussionsPage] Fetched', discussionThreads.length, 'discussion threads') logger.debug('[DiscussionsPage] Fetched', discussionThreads.length, 'discussion threads')
if (discussionThreads.length > 0) { if (discussionThreads.length > 0) {
@ -456,20 +460,32 @@ const DiscussionsPage = forwardRef<TPageRef, { embedded?: boolean }>(function Di
const allThreadIdsArray = Array.from(allThreadIds) const allThreadIdsArray = Array.from(allThreadIds)
const [comments, reactions] = await Promise.all([ const [comments, reactions] = await Promise.all([
allThreadIdsArray.length > 0 ? queryService.fetchEvents(allRelays, [ allThreadIdsArray.length > 0
{ ? queryService.fetchEvents(
kinds: [1111], // ExtendedKind.COMMENT allRelays,
'#e': allThreadIdsArray, [
limit: 500 // Increased from 100 to load more comments per request {
} kinds: [1111], // ExtendedKind.COMMENT
]) : Promise.resolve([]), '#e': allThreadIdsArray,
allThreadIdsArray.length > 0 ? queryService.fetchEvents(allRelays, [ limit: 500 // Increased from 100 to load more comments per request
{ }
kinds: [kinds.Reaction], ],
'#e': allThreadIdsArray, { firstRelayResultGraceMs: false }
limit: 500 // Increased from 100 to load more reactions per request )
} : Promise.resolve([]),
]) : Promise.resolve([]) allThreadIdsArray.length > 0
? queryService.fetchEvents(
allRelays,
[
{
kinds: [kinds.Reaction],
'#e': allThreadIdsArray,
limit: 500 // Increased from 100 to load more reactions per request
}
],
{ firstRelayResultGraceMs: false }
)
: Promise.resolve([])
]) ])
logger.debug('[DiscussionsPage] Fetched', comments.length, 'comments and', reactions.length, 'reactions for', allThreadIdsArray.length, 'threads (', threadIds.length, 'new,', (cachedDataBeforeFetch?.eventMap.size || 0), 'cached)') logger.debug('[DiscussionsPage] Fetched', comments.length, 'comments and', reactions.length, 'reactions for', allThreadIdsArray.length, 'threads (', threadIds.length, 'new,', (cachedDataBeforeFetch?.eventMap.size || 0), 'cached)')

121
src/routes.tsx
Unescape View File

@ -1,58 +1,75 @@
import { match } from 'path-to-regexp' import { match } from 'path-to-regexp'
import { isValidElement } from 'react' import {
import FollowingListPage from './pages/secondary/FollowingListPage' isValidElement,
import GeneralSettingsPage from './pages/secondary/GeneralSettingsPage' lazy,
import MuteListPage from './pages/secondary/MuteListPage' Suspense,
import NoteListPage from './pages/secondary/NoteListPage' type ComponentType,
import NotePage from './pages/secondary/NotePage' type LazyExoticComponent,
import OthersRelaySettingsPage from './pages/secondary/OthersRelaySettingsPage' type ReactElement
import PostSettingsPage from './pages/secondary/PostSettingsPage' } from 'react'
import ProfileEditorPage from './pages/secondary/ProfileEditorPage'
import ProfileListPage from './pages/secondary/ProfileListPage' /** Lazy + Suspense so importing `routes` does not sync-pull pages that depend on PageManager (breaks Vite HMR cycles). */
import ProfilePage from './pages/secondary/ProfilePage' const FollowingListPageLazy = lazy(() => import('./pages/secondary/FollowingListPage'))
import RelayPage from './pages/secondary/RelayPage' const GeneralSettingsPageLazy = lazy(() => import('./pages/secondary/GeneralSettingsPage'))
import RelayReviewsPage from './pages/secondary/RelayReviewsPage' const MuteListPageLazy = lazy(() => import('./pages/secondary/MuteListPage'))
import RelaySettingsPage from './pages/secondary/RelaySettingsPage' const NoteListPageLazy = lazy(() => import('./pages/secondary/NoteListPage'))
import CacheSettingsPage from './pages/secondary/CacheSettingsPage' const NotePageLazy = lazy(() => import('./pages/secondary/NotePage'))
import RssFeedSettingsPage from './pages/secondary/RssFeedSettingsPage' const OthersRelaySettingsPageLazy = lazy(() => import('./pages/secondary/OthersRelaySettingsPage'))
import SearchPage from './pages/secondary/SearchPage' const PostSettingsPageLazy = lazy(() => import('./pages/secondary/PostSettingsPage'))
import SettingsPage from './pages/secondary/SettingsPage' const ProfileEditorPageLazy = lazy(() => import('./pages/secondary/ProfileEditorPage'))
import TranslationPage from './pages/secondary/TranslationPage' const ProfileListPageLazy = lazy(() => import('./pages/secondary/ProfileListPage'))
import WalletPage from './pages/secondary/WalletPage' const ProfilePageLazy = lazy(() => import('./pages/secondary/ProfilePage'))
import FollowPacksRedirect from './pages/secondary/FollowPacksRedirect' const RelayPageLazy = lazy(() => import('./pages/secondary/RelayPage'))
const RelayReviewsPageLazy = lazy(() => import('./pages/secondary/RelayReviewsPage'))
const RelaySettingsPageLazy = lazy(() => import('./pages/secondary/RelaySettingsPage'))
const CacheSettingsPageLazy = lazy(() => import('./pages/secondary/CacheSettingsPage'))
const RssFeedSettingsPageLazy = lazy(() => import('./pages/secondary/RssFeedSettingsPage'))
const SearchPageLazy = lazy(() => import('./pages/secondary/SearchPage'))
const SettingsPageLazy = lazy(() => import('./pages/secondary/SettingsPage'))
const TranslationPageLazy = lazy(() => import('./pages/secondary/TranslationPage'))
const WalletPageLazy = lazy(() => import('./pages/secondary/WalletPage'))
const FollowPacksRedirectLazy = lazy(() => import('./pages/secondary/FollowPacksRedirect'))
const routeSuspenseFallback = null
function SR(C: LazyExoticComponent<ComponentType<Record<string, unknown>>>): ReactElement {
return (
<Suspense fallback={routeSuspenseFallback}>
<C />
</Suspense>
)
}
const ROUTES = [ const ROUTES = [
{ path: '/notes', element: <NoteListPage /> }, { path: '/notes', element: SR(NoteListPageLazy) },
{ path: '/notes/:id', element: <NotePage /> }, { path: '/notes/:id', element: SR(NotePageLazy) },
// Contextual note routes (e.g., /discussions/notes/:id, /search/notes/:id) { path: '/discussions/notes/:id', element: SR(NotePageLazy) },
{ path: '/discussions/notes/:id', element: <NotePage /> }, { path: '/search/notes/:id', element: SR(NotePageLazy) },
{ path: '/search/notes/:id', element: <NotePage /> }, { path: '/profile/notes/:id', element: SR(NotePageLazy) },
{ path: '/profile/notes/:id', element: <NotePage /> }, { path: '/explore/notes/:id', element: SR(NotePageLazy) },
{ path: '/explore/notes/:id', element: <NotePage /> }, { path: '/home/notes/:id', element: SR(NotePageLazy) },
{ path: '/home/notes/:id', element: <NotePage /> }, { path: '/feed/notes/:id', element: SR(NotePageLazy) },
{ path: '/feed/notes/:id', element: <NotePage /> }, { path: '/spells/notes/:id', element: SR(NotePageLazy) },
{ path: '/spells/notes/:id', element: <NotePage /> }, { path: '/users', element: SR(ProfileListPageLazy) },
{ path: '/users', element: <ProfileListPage /> }, { path: '/users/:id', element: SR(ProfilePageLazy) },
{ path: '/users/:id', element: <ProfilePage /> }, { path: '/users/:id/following', element: SR(FollowingListPageLazy) },
{ path: '/users/:id/following', element: <FollowingListPage /> }, { path: '/users/:id/relays', element: SR(OthersRelaySettingsPageLazy) },
{ path: '/users/:id/relays', element: <OthersRelaySettingsPage /> }, { path: '/relays/:url', element: SR(RelayPageLazy) },
{ path: '/relays/:url', element: <RelayPage /> }, { path: '/relays/:url/reviews', element: SR(RelayReviewsPageLazy) },
{ path: '/relays/:url/reviews', element: <RelayReviewsPage /> }, { path: '/home/relays/:url', element: SR(RelayPageLazy) },
// Contextual relay routes (home = explore; legacy /explore) { path: '/explore/relays/:url', element: SR(RelayPageLazy) },
{ path: '/home/relays/:url', element: <RelayPage /> }, { path: '/search', element: SR(SearchPageLazy) },
{ path: '/explore/relays/:url', element: <RelayPage /> }, { path: '/settings', element: SR(SettingsPageLazy) },
{ path: '/search', element: <SearchPage /> }, { path: '/settings/relays', element: SR(RelaySettingsPageLazy) },
{ path: '/settings', element: <SettingsPage /> }, { path: '/settings/cache', element: SR(CacheSettingsPageLazy) },
{ path: '/settings/relays', element: <RelaySettingsPage /> }, { path: '/settings/wallet', element: SR(WalletPageLazy) },
{ path: '/settings/cache', element: <CacheSettingsPage /> }, { path: '/settings/posts', element: SR(PostSettingsPageLazy) },
{ path: '/settings/wallet', element: <WalletPage /> }, { path: '/settings/general', element: SR(GeneralSettingsPageLazy) },
{ path: '/settings/posts', element: <PostSettingsPage /> }, { path: '/settings/translation', element: SR(TranslationPageLazy) },
{ path: '/settings/general', element: <GeneralSettingsPage /> }, { path: '/settings/rss-feeds', element: SR(RssFeedSettingsPageLazy) },
{ path: '/settings/translation', element: <TranslationPage /> }, { path: '/profile-editor', element: SR(ProfileEditorPageLazy) },
{ path: '/settings/rss-feeds', element: <RssFeedSettingsPage /> }, { path: '/mutes', element: SR(MuteListPageLazy) },
{ path: '/profile-editor', element: <ProfileEditorPage /> }, { path: '/follow-packs', element: SR(FollowPacksRedirectLazy) }
{ path: '/mutes', element: <MuteListPage /> },
{ path: '/follow-packs', element: <FollowPacksRedirect /> }
] ]
export const routes = ROUTES.map(({ path, element }) => ({ export const routes = ROUTES.map(({ path, element }) => ({

52
src/services/client-query.service.ts
Unescape View File

@ -1,4 +1,9 @@
import { KIND_1_BLOCKED_RELAY_URLS, SEARCHABLE_RELAY_URLS } from '@/constants' import {
FEED_FIRST_RELAY_RESULT_GRACE_MIN_LIMIT,
FIRST_RELAY_RESULT_GRACE_MS,
KIND_1_BLOCKED_RELAY_URLS,
SEARCHABLE_RELAY_URLS
} from '@/constants'
import logger from '@/lib/logger' import logger from '@/lib/logger'
import { normalizeUrl } from '@/lib/url' import { normalizeUrl } from '@/lib/url'
import type { Filter, Event as NEvent } from 'nostr-tools' import type { Filter, Event as NEvent } from 'nostr-tools'
@ -23,6 +28,13 @@ export interface QueryOptions {
replaceableRaceWaitMs?: number replaceableRaceWaitMs?: number
/** For non-replaceable single events: return immediately on first match */ /** For non-replaceable single events: return immediately on first match */
immediateReturn?: boolean immediateReturn?: boolean
/**
* Multi-relay feed / batch: after first event, wait this many ms then close and return.
* `false` disables (wait for normal EOSE / global timeout). When omitted, implicit grace uses
* {@link FIRST_RELAY_RESULT_GRACE_MS} only if the largest filter `limit` is at least
* {@link FEED_FIRST_RELAY_RESULT_GRACE_MIN_LIMIT} (and not replaceableRace / immediateReturn / single-event fetch).
*/
firstRelayResultGraceMs?: number | false
} }
export interface SubscribeCallbacks { export interface SubscribeCallbacks {
@ -115,7 +127,7 @@ export class QueryService {
const eoseTimeout = options?.eoseTimeout ?? 500 const eoseTimeout = options?.eoseTimeout ?? 500
const globalTimeout = options?.globalTimeout ?? 10000 const globalTimeout = options?.globalTimeout ?? 10000
const replaceableRace = options?.replaceableRace ?? false const replaceableRace = options?.replaceableRace ?? false
const replaceableRaceWaitMs = options?.replaceableRaceWaitMs ?? 2000 const replaceableRaceWaitMs = options?.replaceableRaceWaitMs ?? FIRST_RELAY_RESULT_GRACE_MS
const immediateReturn = options?.immediateReturn ?? false const immediateReturn = options?.immediateReturn ?? false
const isExternalSearch = eoseTimeout > 1000 const isExternalSearch = eoseTimeout > 1000
@ -131,12 +143,25 @@ export class QueryService {
}) })
} }
const FIRST_RESULT_GRACE_MS = 1200 const filtersForGrace = Array.isArray(filter) ? filter : [filter]
const maxLimitForGrace = Math.max(...filtersForGrace.map((f) => (f.limit ?? 0) as number), 0)
const isSingleEventFetchForGrace = maxLimitForGrace === 1
const useImplicitFeedFirstRelayGrace =
maxLimitForGrace >= FEED_FIRST_RELAY_RESULT_GRACE_MIN_LIMIT && !isSingleEventFetchForGrace
const feedGraceMsResolved: number | null =
options?.firstRelayResultGraceMs === false
? null
: typeof options?.firstRelayResultGraceMs === 'number'
? options.firstRelayResultGraceMs
: !replaceableRace && !immediateReturn && useImplicitFeedFirstRelayGrace
? FIRST_RELAY_RESULT_GRACE_MS
: null
return await new Promise<NEvent[]>((resolve) => { return await new Promise<NEvent[]>((resolve) => {
const events: NEvent[] = [] const events: NEvent[] = []
let resolveTimeout: ReturnType<typeof setTimeout> | null = null let resolveTimeout: ReturnType<typeof setTimeout> | null = null
let firstResultGraceTimeoutId: ReturnType<typeof setTimeout> | null = null let firstResultGraceTimeoutId: ReturnType<typeof setTimeout> | null = null
let feedFirstResultGraceTimeoutId: ReturnType<typeof setTimeout> | null = null
let replaceableRaceTimeoutId: ReturnType<typeof setTimeout> | null = null let replaceableRaceTimeoutId: ReturnType<typeof setTimeout> | null = null
let allEosed = false let allEosed = false
let eventCount = 0 let eventCount = 0
@ -178,6 +203,7 @@ export class QueryService {
resolved = true resolved = true
if (resolveTimeout) clearTimeout(resolveTimeout) if (resolveTimeout) clearTimeout(resolveTimeout)
if (firstResultGraceTimeoutId) clearTimeout(firstResultGraceTimeoutId) if (firstResultGraceTimeoutId) clearTimeout(firstResultGraceTimeoutId)
if (feedFirstResultGraceTimeoutId) clearTimeout(feedFirstResultGraceTimeoutId)
if (replaceableRaceTimeoutId) clearTimeout(replaceableRaceTimeoutId) if (replaceableRaceTimeoutId) clearTimeout(replaceableRaceTimeoutId)
if (globalTimeoutId) clearTimeout(globalTimeoutId) if (globalTimeoutId) clearTimeout(globalTimeoutId)
@ -220,11 +246,23 @@ export class QueryService {
}, replaceableRaceWaitMs) }, replaceableRaceWaitMs)
} }
if (
feedGraceMsResolved != null &&
events.length >= 1 &&
!feedFirstResultGraceTimeoutId &&
!replaceableRace
) {
feedFirstResultGraceTimeoutId = setTimeout(() => {
feedFirstResultGraceTimeoutId = null
resolveWithEvents()
}, feedGraceMsResolved)
}
if (!replaceableRace && !immediateReturn && isSingleEventFetch && events.length === 1 && !firstResultGraceTimeoutId) { if (!replaceableRace && !immediateReturn && isSingleEventFetch && events.length === 1 && !firstResultGraceTimeoutId) {
firstResultGraceTimeoutId = setTimeout(() => { firstResultGraceTimeoutId = setTimeout(() => {
firstResultGraceTimeoutId = null firstResultGraceTimeoutId = null
resolveWithEvents() resolveWithEvents()
}, FIRST_RESULT_GRACE_MS) }, FIRST_RELAY_RESULT_GRACE_MS)
} }
if (hasIdFilter && isSingleEventFetch && events.length > 0 && allEosed && !replaceableRace && !immediateReturn) { if (hasIdFilter && isSingleEventFetch && events.length > 0 && allEosed && !replaceableRace && !immediateReturn) {
@ -251,6 +289,7 @@ export class QueryService {
} }
if (firstResultGraceTimeoutId) clearTimeout(firstResultGraceTimeoutId) if (firstResultGraceTimeoutId) clearTimeout(firstResultGraceTimeoutId)
if (feedFirstResultGraceTimeoutId) clearTimeout(feedFirstResultGraceTimeoutId)
if (resolveTimeout) clearTimeout(resolveTimeout) if (resolveTimeout) clearTimeout(resolveTimeout)
resolveTimeout = setTimeout(() => resolveWithEvents(), eoseTimeout) resolveTimeout = setTimeout(() => resolveWithEvents(), eoseTimeout)
} }
@ -446,8 +485,6 @@ export class QueryService {
filter: Filter | Filter[], filter: Filter | Filter[],
options?: { options?: {
onevent?: (evt: NEvent) => void onevent?: (evt: NEvent) => void
eoseTimeout?: number
globalTimeout?: number
} & QueryOptions } & QueryOptions
): Promise<NEvent[]> { ): Promise<NEvent[]> {
let relays = Array.from(new Set(urls)) let relays = Array.from(new Set(urls))
@ -461,6 +498,7 @@ export class QueryService {
const kind1BlockedSet = new Set(KIND_1_BLOCKED_RELAY_URLS.map((u) => normalizeUrl(u) || u)) const kind1BlockedSet = new Set(KIND_1_BLOCKED_RELAY_URLS.map((u) => normalizeUrl(u) || u))
relays = relays.filter((url) => !kind1BlockedSet.has(normalizeUrl(url) || url)) relays = relays.filter((url) => !kind1BlockedSet.has(normalizeUrl(url) || url))
} }
return this.query(relays, filter, options?.onevent, options) const { onevent, ...queryOpts } = options ?? {}
return this.query(relays, filter, onevent, queryOpts)
} }
} }

143
src/services/client-replaceable-events.service.ts
Unescape View File

@ -1,4 +1,10 @@
import { ExtendedKind, FAST_READ_RELAY_URLS, PROFILE_FETCH_RELAY_URLS } from '@/constants' import {
ExtendedKind,
FAST_READ_RELAY_URLS,
METADATA_BATCH_QUERY_EOSE_TIMEOUT_MS,
METADATA_BATCH_QUERY_GLOBAL_TIMEOUT_MS,
PROFILE_FETCH_RELAY_URLS
} from '@/constants'
import { kinds, nip19 } from 'nostr-tools' import { kinds, nip19 } from 'nostr-tools'
import type { Event as NEvent, Filter } from 'nostr-tools' import type { Event as NEvent, Filter } from 'nostr-tools'
import DataLoader from 'dataloader' import DataLoader from 'dataloader'
@ -105,7 +111,7 @@ export class ReplaceableEventService {
containingEventRelays: string[] = [] containingEventRelays: string[] = []
): Promise<NEvent | undefined> { ): Promise<NEvent | undefined> {
const cacheKey = d ? `${kind}:${pubkey}:${d}` : `${kind}:${pubkey}` const cacheKey = d ? `${kind}:${pubkey}:${d}` : `${kind}:${pubkey}`
logger.info('[ReplaceableEventService] fetchReplaceableEvent start', { logger.debug('[ReplaceableEventService] fetchReplaceableEvent start', {
pubkey, pubkey,
kind, kind,
d, d,
@ -119,14 +125,14 @@ export class ReplaceableEventService {
let event: NEvent | undefined let event: NEvent | undefined
if (containingEventRelays.length > 0 && kind === kinds.Metadata && !d) { if (containingEventRelays.length > 0 && kind === kinds.Metadata && !d) {
// For profiles with containing event relays (author's relay list), check IndexedDB first, then query directly // For profiles with containing event relays (author's relay list), check IndexedDB first, then query directly
logger.info('[ReplaceableEventService] Checking IndexedDB for profile with containing relays', { logger.debug('[ReplaceableEventService] Checking IndexedDB for profile with containing relays', {
pubkey, pubkey,
kind kind
}) })
try { try {
const indexedDbCached = await indexedDb.getReplaceableEvent(pubkey, kind, d) const indexedDbCached = await indexedDb.getReplaceableEvent(pubkey, kind, d)
if (indexedDbCached) { if (indexedDbCached) {
logger.info('[ReplaceableEventService] Found in IndexedDB', { logger.debug('[ReplaceableEventService] Found in IndexedDB', {
pubkey, pubkey,
kind, kind,
eventId: indexedDbCached.id eventId: indexedDbCached.id
@ -144,27 +150,32 @@ export class ReplaceableEventService {
} }
// Not in IndexedDB, fetch from network with custom relay list // Not in IndexedDB, fetch from network with custom relay list
logger.info('[ReplaceableEventService] Building relay list with containing event relays', { logger.debug('[ReplaceableEventService] Building relay list with containing event relays', {
pubkey, pubkey,
containingRelayCount: containingEventRelays.length containingRelayCount: containingEventRelays.length
}) })
const relayUrls = await this.buildComprehensiveRelayListForAuthor(pubkey, kind, containingEventRelays, []) const relayUrls = await this.buildComprehensiveRelayListForAuthor(pubkey, kind, containingEventRelays, [])
logger.info('[ReplaceableEventService] Querying relays', { logger.debug('[ReplaceableEventService] Querying relays', {
pubkey, pubkey,
relayCount: relayUrls.length, relayCount: relayUrls.length,
relays: relayUrls.slice(0, 5) relays: relayUrls.slice(0, 5)
}) })
const startTime = Date.now() const startTime = Date.now()
const events = await this.queryService.query(relayUrls, { const events = await this.queryService.query(
authors: [pubkey], relayUrls,
kinds: [kind] {
}, undefined, { authors: [pubkey],
replaceableRace: true, kinds: [kind]
eoseTimeout: 100, // Reduced from 200ms for faster early returns },
globalTimeout: 2000 // Reduced from 3000ms to prevent long waits when many relays are slow undefined,
}) {
replaceableRace: true,
eoseTimeout: METADATA_BATCH_QUERY_EOSE_TIMEOUT_MS,
globalTimeout: METADATA_BATCH_QUERY_GLOBAL_TIMEOUT_MS
}
)
const queryTime = Date.now() - startTime const queryTime = Date.now() - startTime
logger.info('[ReplaceableEventService] Query completed', { logger.debug('[ReplaceableEventService] Query completed', {
pubkey, pubkey,
eventCount: events.length, eventCount: events.length,
queryTime: `${queryTime}ms` queryTime: `${queryTime}ms`
@ -173,7 +184,7 @@ export class ReplaceableEventService {
event = sortedEvents.length > 0 ? sortedEvents[0] : undefined event = sortedEvents.length > 0 ? sortedEvents[0] : undefined
} else { } else {
// Use DataLoader for batching (IndexedDB checks and network fetches are batched) // Use DataLoader for batching (IndexedDB checks and network fetches are batched)
logger.info('[ReplaceableEventService] Using DataLoader (batches IndexedDB + network)', { logger.debug('[ReplaceableEventService] Using DataLoader (batches IndexedDB + network)', {
pubkey, pubkey,
kind, kind,
d d
@ -183,7 +194,7 @@ export class ReplaceableEventService {
? await this.replaceableEventDataLoader.load({ pubkey, kind, d }) ? await this.replaceableEventDataLoader.load({ pubkey, kind, d })
: await this.replaceableEventFromBigRelaysDataloader.load({ pubkey, kind }) : await this.replaceableEventFromBigRelaysDataloader.load({ pubkey, kind })
const loadTime = Date.now() - startTime const loadTime = Date.now() - startTime
logger.info('[ReplaceableEventService] DataLoader completed', { logger.debug('[ReplaceableEventService] DataLoader completed', {
pubkey, pubkey,
found: !!loadedEvent, found: !!loadedEvent,
loadTime: `${loadTime}ms` loadTime: `${loadTime}ms`
@ -192,7 +203,7 @@ export class ReplaceableEventService {
} }
if (event) { if (event) {
logger.info('[ReplaceableEventService] Event found', { logger.debug('[ReplaceableEventService] Event found', {
pubkey, pubkey,
kind, kind,
eventId: event.id, eventId: event.id,
@ -225,7 +236,7 @@ export class ReplaceableEventService {
} }
} }
logger.info('[ReplaceableEventService] fetchReplaceableEvent returning undefined', { logger.debug('[ReplaceableEventService] fetchReplaceableEvent returning undefined', {
pubkey, pubkey,
kind kind
}) })
@ -316,7 +327,7 @@ export class ReplaceableEventService {
): Promise<(NEvent | null)[]> { ): Promise<(NEvent | null)[]> {
// CRITICAL: Reduce logging during rapid scrolling - only log large batches // CRITICAL: Reduce logging during rapid scrolling - only log large batches
if (params.length > 50) { if (params.length > 50) {
logger.info('[ReplaceableEventService] Large batch load function called', { logger.debug('[ReplaceableEventService] Large batch load function called', {
paramCount: params.length, paramCount: params.length,
kind: params[0]?.kind kind: params[0]?.kind
}) })
@ -399,7 +410,7 @@ export class ReplaceableEventService {
// Only log at info level for large batches // Only log at info level for large batches
if (missingParams.length > 50) { if (missingParams.length > 50) {
logger.info('[ReplaceableEventService] Fetching missing events from network', { logger.debug('[ReplaceableEventService] Fetching missing events from network', {
missingCount: missingParams.length, missingCount: missingParams.length,
totalCount: params.length totalCount: params.length
}) })
@ -427,14 +438,38 @@ export class ReplaceableEventService {
// For each pubkey, build comprehensive relay list // For each pubkey, build comprehensive relay list
// CRITICAL FIX: For batch fetches, use default relays instead of fetching relay lists for each author // CRITICAL FIX: For batch fetches, use default relays instead of fetching relay lists for each author
// Fetching relay lists for hundreds of authors causes infinite loops and browser crashes // Fetching relay lists for hundreds of authors causes infinite loops and browser crashes
// Use PROFILE_FETCH_RELAY_URLS + FAST_READ_RELAY_URLS for profiles, or FAST_READ_RELAY_URLS for other kinds // Use PROFILE_FETCH_RELAY_URLS + FAST_READ_RELAY_URLS for profiles, or FAST_READ_RELAY_URLS for other kinds.
const relayUrls = kind === kinds.Metadata // For metadata with a logged-in user, merge defaults with {@link buildComprehensiveRelayList}: inboxes (read),
? Array.from(new Set([...PROFILE_FETCH_RELAY_URLS, ...FAST_READ_RELAY_URLS])) // local/cache relays (10432), favorite relays (10012), plus profile + fast read — same idea as favorites feed
: [...FAST_READ_RELAY_URLS] // / inbox-scoped discovery without per-author relay list fetches.
let relayUrls: string[]
if (kind === kinds.Metadata) {
const userPk = client.pubkey
if (userPk) {
try {
relayUrls = await buildComprehensiveRelayList({
userPubkey: userPk,
includeUserOwnRelays: false,
includeProfileFetchRelays: true,
includeFastReadRelays: true,
includeFavoriteRelays: true,
includeLocalRelays: true,
includeFastWriteRelays: false,
includeSearchableRelays: false
})
} catch {
relayUrls = Array.from(new Set([...PROFILE_FETCH_RELAY_URLS, ...FAST_READ_RELAY_URLS]))
}
} else {
relayUrls = Array.from(new Set([...PROFILE_FETCH_RELAY_URLS, ...FAST_READ_RELAY_URLS]))
}
} else {
relayUrls = [...FAST_READ_RELAY_URLS]
}
// Only log at info level for large batches // Only log at info level for large batches
if (pubkeys.length > 50) { if (pubkeys.length > 50) {
logger.info('[ReplaceableEventService] Starting query for large batch', { logger.debug('[ReplaceableEventService] Starting query for large batch', {
kind, kind,
pubkeyCount: pubkeys.length, pubkeyCount: pubkeys.length,
relayCount: relayUrls.length relayCount: relayUrls.length
@ -446,17 +481,23 @@ export class ReplaceableEventService {
relayCount: relayUrls.length relayCount: relayUrls.length
}) })
} }
const events = await this.queryService.query(relayUrls, { const isMetadataBatch = kind === kinds.Metadata
authors: pubkeys, const events = await this.queryService.query(
kinds: [kind] relayUrls,
}, undefined, { {
replaceableRace: true, authors: pubkeys,
eoseTimeout: 100, // Reduced from 200ms for faster early returns kinds: [kind]
globalTimeout: 2000 // Reduced from 3000ms to prevent long waits when many relays are slow },
}) undefined,
{
replaceableRace: true,
eoseTimeout: isMetadataBatch ? METADATA_BATCH_QUERY_EOSE_TIMEOUT_MS : 100,
globalTimeout: isMetadataBatch ? METADATA_BATCH_QUERY_GLOBAL_TIMEOUT_MS : 2000
}
)
// Only log at info level for large batches or if many events found // Only log at info level for large batches or if many events found
if (pubkeys.length > 50 || events.length > 100) { if (pubkeys.length > 50 || events.length > 100) {
logger.info('[ReplaceableEventService] Query completed for batch', { logger.debug('[ReplaceableEventService] Query completed for batch', {
kind, kind,
pubkeyCount: pubkeys.length, pubkeyCount: pubkeys.length,
eventCount: events.length eventCount: events.length
@ -488,7 +529,7 @@ export class ReplaceableEventService {
} }
// Convert back to array, but limit to reasonable size // Convert back to array, but limit to reasonable size
const limitedEvents = Array.from(eventsByPubkey.values()).slice(0, 500) const limitedEvents = Array.from(eventsByPubkey.values()).slice(0, 500)
logger.info('[ReplaceableEventService] Limited batch size', { logger.debug('[ReplaceableEventService] Limited batch size', {
originalCount: events.length, originalCount: events.length,
limitedCount: limitedEvents.length limitedCount: limitedEvents.length
}) })
@ -550,7 +591,7 @@ export class ReplaceableEventService {
// Only log at info level for large batches // Only log at info level for large batches
if (params.length > 50) { if (params.length > 50) {
logger.info('[ReplaceableEventService] Batch load function completed', { logger.debug('[ReplaceableEventService] Batch load function completed', {
paramCount: params.length, paramCount: params.length,
foundCount: results.filter(r => r !== null).length, foundCount: results.filter(r => r !== null).length,
indexedDbCount: params.length - missingParams.length, indexedDbCount: params.length - missingParams.length,
@ -645,17 +686,17 @@ export class ReplaceableEventService {
* Fetch profile event by id (hex, npub, nprofile) * Fetch profile event by id (hex, npub, nprofile)
*/ */
async fetchProfileEvent(id: string, _skipCache: boolean = false): Promise<NEvent | undefined> { async fetchProfileEvent(id: string, _skipCache: boolean = false): Promise<NEvent | undefined> {
logger.info('[ReplaceableEventService] fetchProfileEvent start', { id }) logger.debug('[ReplaceableEventService] fetchProfileEvent start', { id })
let pubkey: string | undefined let pubkey: string | undefined
let relays: string[] = [] let relays: string[] = []
if (/^[0-9a-f]{64}$/.test(id)) { if (/^[0-9a-f]{64}$/.test(id)) {
pubkey = id pubkey = id
logger.info('[ReplaceableEventService] ID is hex pubkey', { pubkey }) logger.debug('[ReplaceableEventService] ID is hex pubkey', { pubkey })
} else { } else {
try { try {
const { data, type } = nip19.decode(id) const { data, type } = nip19.decode(id)
logger.info('[ReplaceableEventService] Decoded bech32 ID', { type }) logger.debug('[ReplaceableEventService] Decoded bech32 ID', { type })
switch (type) { switch (type) {
case 'npub': case 'npub':
pubkey = data pubkey = data
@ -663,7 +704,7 @@ export class ReplaceableEventService {
case 'nprofile': case 'nprofile':
pubkey = data.pubkey pubkey = data.pubkey
if (data.relays) relays = data.relays if (data.relays) relays = data.relays
logger.info('[ReplaceableEventService] nprofile has relay hints', { relayCount: relays.length }) logger.debug('[ReplaceableEventService] nprofile has relay hints', { relayCount: relays.length })
break break
} }
} catch (error) { } catch (error) {
@ -687,7 +728,7 @@ export class ReplaceableEventService {
// CRITICAL: Do NOT pass relay hints here - passing any relays bypasses DataLoader and creates individual subscriptions // CRITICAL: Do NOT pass relay hints here - passing any relays bypasses DataLoader and creates individual subscriptions
// DataLoader already uses default relays internally and batches all profile fetches // DataLoader already uses default relays internally and batches all profile fetches
// We'll use relay hints in Step 2/3 only if Step 1 fails // We'll use relay hints in Step 2/3 only if Step 1 fails
logger.info('[ReplaceableEventService] Step 1: Trying with DataLoader (checks cache first, uses default relays, batched)', { logger.debug('[ReplaceableEventService] Step 1: Trying with DataLoader (checks cache first, uses default relays, batched)', {
pubkey, pubkey,
relayHintCount: relayHints.length, relayHintCount: relayHints.length,
hasRelayHints: relayHints.length > 0 hasRelayHints: relayHints.length > 0
@ -698,7 +739,7 @@ export class ReplaceableEventService {
const profileEvent = await this.fetchReplaceableEvent(pubkey, kinds.Metadata, undefined, []) const profileEvent = await this.fetchReplaceableEvent(pubkey, kinds.Metadata, undefined, [])
if (profileEvent) { if (profileEvent) {
logger.info('[ReplaceableEventService] Profile found with relay hints + default relays', { logger.debug('[ReplaceableEventService] Profile found with relay hints + default relays', {
pubkey, pubkey,
eventId: profileEvent.id eventId: profileEvent.id
}) })
@ -710,7 +751,7 @@ export class ReplaceableEventService {
// This prevents creating many individual subscriptions when profiles aren't found // This prevents creating many individual subscriptions when profiles aren't found
// If we have relay hints, it's worth trying author relays. Otherwise, Step 1 should be sufficient. // If we have relay hints, it's worth trying author relays. Otherwise, Step 1 should be sufficient.
if (relayHints.length > 0) { if (relayHints.length > 0) {
logger.info('[ReplaceableEventService] Step 2: Profile not found, but we have relay hints - fetching author relay list as fallback', { logger.debug('[ReplaceableEventService] Step 2: Profile not found, but we have relay hints - fetching author relay list as fallback', {
pubkey, pubkey,
relayHintCount: relayHints.length relayHintCount: relayHints.length
}) })
@ -730,7 +771,7 @@ export class ReplaceableEventService {
}) })
authorRelayList = await Promise.race([relayListPromise, timeoutPromise]) authorRelayList = await Promise.race([relayListPromise, timeoutPromise])
const relayListTime = Date.now() - relayListStartTime const relayListTime = Date.now() - relayListStartTime
logger.info('[ReplaceableEventService] Author relay list fetched', { logger.debug('[ReplaceableEventService] Author relay list fetched', {
pubkey, pubkey,
hasRelayList: !!authorRelayList, hasRelayList: !!authorRelayList,
fetchTime: `${relayListTime}ms` fetchTime: `${relayListTime}ms`
@ -757,7 +798,7 @@ export class ReplaceableEventService {
...FAST_READ_RELAY_URLS // Fast read relays ...FAST_READ_RELAY_URLS // Fast read relays
])] ])]
logger.info('[ReplaceableEventService] Step 3: Trying with relay hints + author relays', { logger.debug('[ReplaceableEventService] Step 3: Trying with relay hints + author relays', {
pubkey, pubkey,
relayHintCount: relayHints.length, relayHintCount: relayHints.length,
authorRelayCount: authorRelays.length, authorRelayCount: authorRelays.length,
@ -773,7 +814,7 @@ export class ReplaceableEventService {
) )
if (profileEventFromAuthorRelays) { if (profileEventFromAuthorRelays) {
logger.info('[ReplaceableEventService] Profile found with relay hints + author relays', { logger.debug('[ReplaceableEventService] Profile found with relay hints + author relays', {
pubkey, pubkey,
eventId: profileEventFromAuthorRelays.id eventId: profileEventFromAuthorRelays.id
}) })
@ -795,7 +836,7 @@ export class ReplaceableEventService {
// when user explicitly navigates to a profile page. For feed rendering, missing profiles are acceptable. // when user explicitly navigates to a profile page. For feed rendering, missing profiles are acceptable.
// Only run comprehensive search if we have relay hints (suggesting user intent to find this specific profile) // Only run comprehensive search if we have relay hints (suggesting user intent to find this specific profile)
if (relayHints.length > 0) { if (relayHints.length > 0) {
logger.info('[ReplaceableEventService] Step 3: Profile not found, trying comprehensive relay list (all available relays)', { logger.debug('[ReplaceableEventService] Step 3: Profile not found, trying comprehensive relay list (all available relays)', {
pubkey, pubkey,
hasRelayHints: relayHints.length > 0 hasRelayHints: relayHints.length > 0
}) })
@ -815,7 +856,7 @@ export class ReplaceableEventService {
includeLocalRelays: true // Include local/cache relays includeLocalRelays: true // Include local/cache relays
}) })
logger.info('[ReplaceableEventService] Comprehensive relay list built', { logger.debug('[ReplaceableEventService] Comprehensive relay list built', {
pubkey, pubkey,
relayCount: comprehensiveRelays.length, relayCount: comprehensiveRelays.length,
relays: comprehensiveRelays.slice(0, 10) // Log first 10 for debugging relays: comprehensiveRelays.slice(0, 10) // Log first 10 for debugging
@ -834,7 +875,7 @@ export class ReplaceableEventService {
}) })
const queryTime = Date.now() - startTime const queryTime = Date.now() - startTime
logger.info('[ReplaceableEventService] Comprehensive search completed', { logger.debug('[ReplaceableEventService] Comprehensive search completed', {
pubkey, pubkey,
eventCount: events.length, eventCount: events.length,
queryTime: `${queryTime}ms`, queryTime: `${queryTime}ms`,
@ -844,7 +885,7 @@ export class ReplaceableEventService {
if (events.length > 0) { if (events.length > 0) {
const sortedEvents = events.sort((a, b) => b.created_at - a.created_at) const sortedEvents = events.sort((a, b) => b.created_at - a.created_at)
const profileEvent = sortedEvents[0] const profileEvent = sortedEvents[0]
logger.info('[ReplaceableEventService] Profile found via comprehensive search', { logger.debug('[ReplaceableEventService] Profile found via comprehensive search', {
pubkey, pubkey,
eventId: profileEvent.id eventId: profileEvent.id
}) })

211
src/services/client.service.ts
Unescape View File

@ -1,4 +1,14 @@
import { FAST_READ_RELAY_URLS, ExtendedKind, FAST_WRITE_RELAY_URLS, KIND_1_BLOCKED_RELAY_URLS, NIP66_DISCOVERY_RELAY_URLS, PROFILE_FETCH_RELAY_URLS, READ_ONLY_RELAY_URLS, SEARCHABLE_RELAY_URLS } from '@/constants' import {
FAST_READ_RELAY_URLS,
ExtendedKind,
FAST_WRITE_RELAY_URLS,
FIRST_RELAY_RESULT_GRACE_MS,
KIND_1_BLOCKED_RELAY_URLS,
NIP66_DISCOVERY_RELAY_URLS,
PROFILE_FETCH_RELAY_URLS,
READ_ONLY_RELAY_URLS,
SEARCHABLE_RELAY_URLS
} from '@/constants'
/** NIP-01 filter keys only; NIP-50 adds `search` which non-searchable relays reject. */ /** NIP-01 filter keys only; NIP-50 adds `search` which non-searchable relays reject. */
function filterForRelay(f: Filter, relaySupportsSearch: boolean): Filter { function filterForRelay(f: Filter, relaySupportsSearch: boolean): Filter {
@ -1004,6 +1014,15 @@ class ClientService extends EventTarget {
return { url, filters: filtersForRelay } return { url, filters: filtersForRelay }
}) })
// Kind-1 queries drop KIND_1_BLOCKED_RELAY_URLS; if every URL was removed, no subs run and
// oneose would never fire — timelines stay loading forever (e.g. favorites feed).
if (groupedRequests.length === 0) {
queueMicrotask(() => oneose?.(true))
return {
close: () => {}
}
}
const eosesReceived: boolean[] = [] const eosesReceived: boolean[] = []
const closesReceived: (string | undefined)[] = [] const closesReceived: (string | undefined)[] = []
const handleEose = (i: number) => { const handleEose = (i: number) => {
@ -1243,6 +1262,7 @@ class ClientService extends EventTarget {
const PROGRESSIVE_INTERVAL_MS = 100 // Poll for more events while relays are still streaming const PROGRESSIVE_INTERVAL_MS = 100 // Poll for more events while relays are still streaming
const MIN_NEW_EVENTS_AFTER_FIRST = 5 // After first paint, batch updates to limit re-renders const MIN_NEW_EVENTS_AFTER_FIRST = 5 // After first paint, batch updates to limit re-renders
let progressiveIntervalId: ReturnType<typeof setInterval> | null = null let progressiveIntervalId: ReturnType<typeof setInterval> | null = null
let firstRelayResultGraceTimer: ReturnType<typeof setTimeout> | null = null
const deliverProgressive = () => { const deliverProgressive = () => {
if (eosedAt || events.length === 0) return if (eosedAt || events.length === 0) return
const sortedEvents = [...events].sort((a, b) => b.created_at - a.created_at).slice(0, filter.limit) const sortedEvents = [...events].sort((a, b) => b.created_at - a.created_at).slice(0, filter.limit)
@ -1261,6 +1281,88 @@ class ClientService extends EventTarget {
onEvents(needSort && useCache ? snap.concat(cachedEvents).slice(0, filter.limit) : snap, false) onEvents(needSort && useCache ? snap.concat(cachedEvents).slice(0, filter.limit) : snap, false)
} }
} }
const handleTimelineEose = (eosed: boolean) => {
if (eosed && eosedAt != null) return
if (eosed && !eosedAt) {
if (firstRelayResultGraceTimer != null) {
clearTimeout(firstRelayResultGraceTimer)
firstRelayResultGraceTimer = null
}
eosedAt = dayjs().unix()
if (progressiveIntervalId) {
clearInterval(progressiveIntervalId)
progressiveIntervalId = null
}
}
// (algo feeds) no need to sort and cache
if (!needSort) {
return onEvents([...events], !!eosedAt)
}
if (!eosed) {
events = events.sort((a, b) => b.created_at - a.created_at).slice(0, filter.limit)
// Only include cached events if caching is enabled
return onEvents([...(useCache ? events.concat(cachedEvents).slice(0, filter.limit) : events)], false)
}
events = events.sort((a, b) => b.created_at - a.created_at).slice(0, filter.limit)
// Only update timeline cache if caching is enabled
if (useCache) {
const timeline = that.timelines[key]
// no cache yet
if (!timeline || Array.isArray(timeline) || !timeline.refs.length) {
that.timelines[key] = {
refs: events.map((evt) => [evt.id, evt.created_at]),
filter,
urls
}
return onEvents([...events], true)
}
// Prevent concurrent requests from duplicating the same event
const firstRefCreatedAt = timeline.refs[0][1]
const newRefs = events
.filter((evt) => evt.created_at > firstRefCreatedAt)
.map((evt) => [evt.id, evt.created_at] as TTimelineRef)
if (events.length >= filter.limit) {
// if new refs are more than limit, means old refs are too old, replace them
timeline.refs = newRefs
onEvents([...events], true)
} else {
// merge new refs with old refs
timeline.refs = newRefs.concat(timeline.refs)
onEvents([...events.concat(cachedEvents).slice(0, filter.limit)], true)
}
} else {
// No caching for initial load, but still need to initialize timeline.refs for loadMoreTimeline pagination
const timeline = that.timelines[key]
if (!timeline || Array.isArray(timeline)) {
// Initialize timeline with refs for pagination (even though we don't use cache for initial load)
that.timelines[key] = {
refs: events.map((evt) => [evt.id, evt.created_at]),
filter,
urls
}
} else {
// Update refs with new events for pagination tracking
const firstRefCreatedAt = timeline.refs.length > 0 ? timeline.refs[0][1] : dayjs().unix()
const newRefs = events
.filter((evt) => evt.created_at > firstRefCreatedAt)
.map((evt) => [evt.id, evt.created_at] as TTimelineRef)
if (events.length >= filter.limit) {
timeline.refs = newRefs
} else {
timeline.refs = newRefs.concat(timeline.refs)
}
}
// Return events directly (no cache concatenation)
onEvents([...events], true)
}
}
const subCloser = this.subscribe(relays, since ? { ...filter, since } : filter, { const subCloser = this.subscribe(relays, since ? { ...filter, since } : filter, {
startLogin, startLogin,
onevent: (evt: NEvent) => { onevent: (evt: NEvent) => {
@ -1268,6 +1370,12 @@ class ClientService extends EventTarget {
// not eosed yet, push to events // not eosed yet, push to events
if (!eosedAt) { if (!eosedAt) {
events.push(evt) events.push(evt)
if (firstRelayResultGraceTimer == null) {
firstRelayResultGraceTimer = setTimeout(() => {
firstRelayResultGraceTimer = null
handleTimelineEose(true)
}, FIRST_RELAY_RESULT_GRACE_MS)
}
// Deliver as soon as we have any event while waiting for EOSE (then batch further updates) // Deliver as soon as we have any event while waiting for EOSE (then batch further updates)
if (needSort && events.length >= 1 && !initialBatchScheduled) { if (needSort && events.length >= 1 && !initialBatchScheduled) {
initialBatchScheduled = true initialBatchScheduled = true
@ -1313,86 +1421,17 @@ class ClientService extends EventTarget {
// insert the event to the right position // insert the event to the right position
timeline.refs.splice(idx, 0, [evt.id, evt.created_at]) timeline.refs.splice(idx, 0, [evt.id, evt.created_at])
}, },
oneose: (eosed) => { oneose: handleTimelineEose,
if (eosed && !eosedAt) {
eosedAt = dayjs().unix()
if (progressiveIntervalId) {
clearInterval(progressiveIntervalId)
progressiveIntervalId = null
}
}
// (algo feeds) no need to sort and cache
if (!needSort) {
return onEvents([...events], !!eosedAt)
}
if (!eosed) {
events = events.sort((a, b) => b.created_at - a.created_at).slice(0, filter.limit)
// Only include cached events if caching is enabled
return onEvents([...(useCache ? events.concat(cachedEvents).slice(0, filter.limit) : events)], false)
}
events = events.sort((a, b) => b.created_at - a.created_at).slice(0, filter.limit)
// Only update timeline cache if caching is enabled
if (useCache) {
const timeline = that.timelines[key]
// no cache yet
if (!timeline || Array.isArray(timeline) || !timeline.refs.length) {
that.timelines[key] = {
refs: events.map((evt) => [evt.id, evt.created_at]),
filter,
urls
}
return onEvents([...events], true)
}
// Prevent concurrent requests from duplicating the same event
const firstRefCreatedAt = timeline.refs[0][1]
const newRefs = events
.filter((evt) => evt.created_at > firstRefCreatedAt)
.map((evt) => [evt.id, evt.created_at] as TTimelineRef)
if (events.length >= filter.limit) {
// if new refs are more than limit, means old refs are too old, replace them
timeline.refs = newRefs
onEvents([...events], true)
} else {
// merge new refs with old refs
timeline.refs = newRefs.concat(timeline.refs)
onEvents([...events.concat(cachedEvents).slice(0, filter.limit)], true)
}
} else {
// No caching for initial load, but still need to initialize timeline.refs for loadMoreTimeline pagination
const timeline = that.timelines[key]
if (!timeline || Array.isArray(timeline)) {
// Initialize timeline with refs for pagination (even though we don't use cache for initial load)
that.timelines[key] = {
refs: events.map((evt) => [evt.id, evt.created_at]),
filter,
urls
}
} else {
// Update refs with new events for pagination tracking
const firstRefCreatedAt = timeline.refs.length > 0 ? timeline.refs[0][1] : dayjs().unix()
const newRefs = events
.filter((evt) => evt.created_at > firstRefCreatedAt)
.map((evt) => [evt.id, evt.created_at] as TTimelineRef)
if (events.length >= filter.limit) {
timeline.refs = newRefs
} else {
timeline.refs = newRefs.concat(timeline.refs)
}
}
// Return events directly (no cache concatenation)
onEvents([...events], true)
}
},
onclose: onClose onclose: onClose
}) })
return { return {
timelineKey: key, timelineKey: key,
closer: () => { closer: () => {
if (firstRelayResultGraceTimer != null) {
clearTimeout(firstRelayResultGraceTimer)
firstRelayResultGraceTimer = null
}
if (progressiveIntervalId) { if (progressiveIntervalId) {
clearInterval(progressiveIntervalId) clearInterval(progressiveIntervalId)
progressiveIntervalId = null progressiveIntervalId = null
@ -1529,6 +1568,7 @@ class ClientService extends EventTarget {
replaceableRace?: boolean replaceableRace?: boolean
/** For non-replaceable single events: return immediately on first match */ /** For non-replaceable single events: return immediately on first match */
immediateReturn?: boolean immediateReturn?: boolean
firstRelayResultGraceMs?: number | false
} }
) { ) {
return this.queryService.query(urls, filter, onevent, options) return this.queryService.query(urls, filter, onevent, options)
@ -1543,12 +1583,18 @@ class ClientService extends EventTarget {
onevent, onevent,
cache = false, cache = false,
eoseTimeout, eoseTimeout,
globalTimeout globalTimeout,
firstRelayResultGraceMs,
replaceableRace,
immediateReturn
}: { }: {
onevent?: (evt: NEvent) => void onevent?: (evt: NEvent) => void
cache?: boolean cache?: boolean
eoseTimeout?: number eoseTimeout?: number
globalTimeout?: number globalTimeout?: number
firstRelayResultGraceMs?: number | false
replaceableRace?: boolean
immediateReturn?: boolean
} = {} } = {}
) { ) {
let relays = Array.from(new Set(urls)) let relays = Array.from(new Set(urls))
@ -1559,12 +1605,13 @@ class ClientService extends EventTarget {
const kind1BlockedSet = new Set(KIND_1_BLOCKED_RELAY_URLS.map((u) => normalizeUrl(u) || u)) const kind1BlockedSet = new Set(KIND_1_BLOCKED_RELAY_URLS.map((u) => normalizeUrl(u) || u))
relays = relays.filter((url) => !kind1BlockedSet.has(normalizeUrl(url) || url)) relays = relays.filter((url) => !kind1BlockedSet.has(normalizeUrl(url) || url))
} }
const events = await this.queryService.query( const events = await this.queryService.query(relays, filter, onevent, {
relays, eoseTimeout,
filter, globalTimeout,
onevent, firstRelayResultGraceMs,
{ eoseTimeout, globalTimeout } replaceableRace,
) immediateReturn
})
if (cache) { if (cache) {
events.forEach((evt) => { events.forEach((evt) => {
this.addEventToCache(evt) this.addEventToCache(evt)

17
src/services/navigation.service.ts
Unescape View File

@ -5,7 +5,7 @@
* Handles all navigation logic in a clean, testable way. * Handles all navigation logic in a clean, testable way.
*/ */
import React, { ReactNode } from 'react' import React, { lazy, ReactNode, Suspense } from 'react'
// Page components // Page components
import SettingsPage from '@/pages/secondary/SettingsPage' import SettingsPage from '@/pages/secondary/SettingsPage'
@ -21,7 +21,14 @@ import FollowingListPage from '@/pages/secondary/FollowingListPage'
import MuteListPage from '@/pages/secondary/MuteListPage' import MuteListPage from '@/pages/secondary/MuteListPage'
import OthersRelaySettingsPage from '@/pages/secondary/OthersRelaySettingsPage' import OthersRelaySettingsPage from '@/pages/secondary/OthersRelaySettingsPage'
import SecondaryRelayPage from '@/pages/secondary/RelayPage' import SecondaryRelayPage from '@/pages/secondary/RelayPage'
import SecondaryNoteListPage from '@/pages/secondary/NoteListPage' /** Lazy avoids: NavigationService → NoteListPage → NormalFeed → NoteList → PageManager → navigation.service */
const SecondaryNoteListPageLazy = lazy(() => import('@/pages/secondary/NoteListPage'))
const navLazyFallback = React.createElement(
'div',
{ className: 'flex flex-1 items-center justify-center p-8 text-sm text-muted-foreground' },
'Loading…'
)
export type ViewType = 'note' | 'settings' | 'settings-sub' | 'profile' | 'hashtag' | 'relay' | 'following' | 'mute' | 'others-relay-settings' | null export type ViewType = 'note' | 'settings' | 'settings-sub' | 'profile' | 'hashtag' | 'relay' | 'following' | 'mute' | 'others-relay-settings' | null
@ -87,7 +94,11 @@ export class ComponentFactory {
} }
static createHashtagPage(): ReactNode { static createHashtagPage(): ReactNode {
return React.createElement(SecondaryNoteListPage, { hideTitlebar: true }) return React.createElement(
Suspense,
{ fallback: navLazyFallback },
React.createElement(SecondaryNoteListPageLazy, { hideTitlebar: true })
)
} }
static createFollowingListPage(profileId: string): ReactNode { static createFollowingListPage(profileId: string): ReactNode {

Write Preview
Loading…
Cancel
Save