101 lines
2.9 KiB
TypeScript
101 lines
2.9 KiB
TypeScript
import { useEffect, useMemo, useRef, useState } from 'react'
|
|
import { nostrService } from '@/lib/nostr'
|
|
import type { Article } from '@/types/nostr'
|
|
import { applyFiltersAndSort } from '@/lib/articleFiltering'
|
|
import type { ArticleFilters } from '@/components/ArticleFilters'
|
|
import { t } from '@/lib/i18n'
|
|
|
|
export function useArticles(searchQuery: string = '', filters: ArticleFilters | null = null): {
|
|
articles: Article[]
|
|
allArticles: Article[]
|
|
loading: boolean
|
|
error: string | null
|
|
loadArticleContent: (articleId: string, authorPubkey: string) => Promise<Article | null>
|
|
} {
|
|
const [articles, setArticles] = useState<Article[]>([])
|
|
const [loading, setLoading] = useState(true)
|
|
const [error, setError] = useState<string | null>(null)
|
|
const hasArticlesRef = useRef(false)
|
|
|
|
useEffect(() => {
|
|
setLoading(true)
|
|
setError(null)
|
|
|
|
const unsubscribe = nostrService.subscribeToArticles(
|
|
(article) => {
|
|
setArticles((prev) => {
|
|
if (prev.some((a) => a.id === article.id)) {
|
|
return prev
|
|
}
|
|
const next = [article, ...prev].sort((a, b) => b.createdAt - a.createdAt)
|
|
hasArticlesRef.current = next.length > 0
|
|
return next
|
|
})
|
|
setLoading(false)
|
|
},
|
|
50
|
|
)
|
|
|
|
const timeout = setTimeout(() => {
|
|
setLoading(false)
|
|
if (!hasArticlesRef.current) {
|
|
setError(t('common.error.noContent'))
|
|
}
|
|
}, 10000)
|
|
|
|
return () => {
|
|
unsubscribe()
|
|
clearTimeout(timeout)
|
|
}
|
|
}, [])
|
|
|
|
const loadArticleContent = async (articleId: string, authorPubkey: string): Promise<Article | null> => {
|
|
try {
|
|
const article = await nostrService.getArticleById(articleId)
|
|
if (article) {
|
|
// Try to decrypt article content using decryption key from private messages
|
|
const decryptedContent = await nostrService.getDecryptedArticleContent(articleId, authorPubkey)
|
|
if (decryptedContent) {
|
|
setArticles((prev) =>
|
|
prev.map((a) =>
|
|
(a.id === articleId
|
|
? { ...a, content: decryptedContent, paid: true }
|
|
: a)
|
|
)
|
|
)
|
|
}
|
|
return article
|
|
}
|
|
} catch (e) {
|
|
console.error('Error loading article content:', e)
|
|
setError(e instanceof Error ? e.message : 'Failed to load article')
|
|
}
|
|
return null
|
|
}
|
|
|
|
// Apply filters and sorting
|
|
const filteredArticles = useMemo(() => {
|
|
const effectiveFilters =
|
|
filters ??
|
|
({
|
|
authorPubkey: null,
|
|
sortBy: 'newest',
|
|
category: 'all',
|
|
} as const)
|
|
|
|
if (!filters && !searchQuery.trim()) {
|
|
return articles
|
|
}
|
|
|
|
return applyFiltersAndSort(articles, searchQuery, effectiveFilters)
|
|
}, [articles, searchQuery, filters])
|
|
|
|
return {
|
|
articles: filteredArticles,
|
|
allArticles: articles, // Return all articles for filters component
|
|
loading,
|
|
error,
|
|
loadArticleContent,
|
|
}
|
|
}
|