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

render book wikilinks

imwald
Silberengel 3 months ago
parent
e755b9ed75
commit
5a27bdd9b5
3 changed files with 143 additions and 382 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. 268
      src/components/Bookstr/BookstrContent.tsx
  2. 46
      src/lib/bookstr-parser.ts
  3. 163
      src/services/client.service.ts

268
src/components/Bookstr/BookstrContent.tsx
Unescape View File

@ -3,7 +3,7 @@ import { Event } from 'nostr-tools'
import { parseBookWikilink, extractBookMetadata, BookReference } from '@/lib/bookstr-parser' import { parseBookWikilink, extractBookMetadata, BookReference } from '@/lib/bookstr-parser'
import client from '@/services/client.service' import client from '@/services/client.service'
import { ExtendedKind } from '@/constants' import { ExtendedKind } from '@/constants'
import { Loader2, AlertCircle, ChevronDown, ChevronUp, ExternalLink } from 'lucide-react' import { Loader2, AlertCircle, ExternalLink } from 'lucide-react'
import { Button } from '@/components/ui/button' import { Button } from '@/components/ui/button'
import { import {
Select, Select,
@ -61,13 +61,9 @@ export function BookstrContent({ wikilink, className }: BookstrContentProps) {
const [sections, setSections] = useState<BookSection[]>([]) const [sections, setSections] = useState<BookSection[]>([])
const [isLoading, setIsLoading] = useState(false) // Start as false, only set to true when actually fetching const [isLoading, setIsLoading] = useState(false) // Start as false, only set to true when actually fetching
const [error, setError] = useState<string | null>(null) const [error, setError] = useState<string | null>(null)
const [expandedSections, setExpandedSections] = useState<Set<number>>(new Set())
const [selectedVersions, setSelectedVersions] = useState<Map<number, string>>(new Map()) const [selectedVersions, setSelectedVersions] = useState<Map<number, string>>(new Map())
const [collapsedCards, setCollapsedCards] = useState<Set<number>>(new Set())
const [cardHeights, setCardHeights] = useState<Map<number, number>>(new Map())
// Track which sections are still loading (by reference key) // Track which sections are still loading (by reference key)
const [loadingSections, setLoadingSections] = useState<Set<string>>(new Set()) const [loadingSections, setLoadingSections] = useState<Set<string>>(new Set())
const cardRefs = useRef<Map<number, HTMLDivElement>>(new Map())
// Parse the wikilink - use a ref to store the last parsed result for comparison // Parse the wikilink - use a ref to store the last parsed result for comparison
const parsedRef = useRef<ReturnType<typeof parseBookWikilink> & { bookType: string } | null>(null) const parsedRef = useRef<ReturnType<typeof parseBookWikilink> & { bookType: string } | null>(null)
@ -701,68 +697,6 @@ export function BookstrContent({ wikilink, className }: BookstrContentProps) {
} }
}, [wikilink]) // Depend on wikilink directly - it's a stable string, parsed is derived from it }, [wikilink]) // Depend on wikilink directly - it's a stable string, parsed is derived from it
// Measure card heights - measure BEFORE applying collapse
useEffect(() => {
const timeoutId = setTimeout(() => {
cardRefs.current.forEach((element, index) => {
if (element) {
// IMPORTANT: Temporarily remove ALL constraints to get true height
// This must happen BEFORE any collapse is applied
const originalMaxHeight = element.style.maxHeight
const originalOverflow = element.style.overflow
const originalHeight = element.style.height
// Remove all constraints
element.style.maxHeight = 'none'
element.style.overflow = 'visible'
element.style.height = 'auto'
// Force a reflow to ensure we get the true height
void element.offsetHeight
const height = element.scrollHeight
// Restore original styles
element.style.maxHeight = originalMaxHeight
element.style.overflow = originalOverflow
element.style.height = originalHeight
// Store the TRUE height (before collapse)
setCardHeights(prev => {
const currentHeight = prev.get(index)
if (currentHeight !== height && height > 0) {
const newMap = new Map(prev)
newMap.set(index, height)
logger.debug('BookstrContent: Measured card height', {
sectionIndex: index,
height,
needsCollapse: height > 500,
wasCollapsed: collapsedCards.has(index)
})
// Only auto-collapse if height > 500px and not already manually toggled
if (height > 500) {
setCollapsedCards(prevCollapsed => {
// Only auto-collapse if user hasn't manually expanded it
if (!prevCollapsed.has(index)) {
logger.debug('BookstrContent: Auto-collapsing card', { sectionIndex: index, height })
return new Set(prevCollapsed).add(index)
}
return prevCollapsed
})
}
return newMap
}
return prev
})
}
})
}, 500) // Wait longer for content to fully render
return () => clearTimeout(timeoutId)
}, [sections, collapsedCards])
// Show loading spinner only if we're actively loading AND have no sections // Show loading spinner only if we're actively loading AND have no sections
// Once we have sections (even empty placeholders), show them instead // Once we have sections (even empty placeholders), show them instead
@ -815,52 +749,19 @@ export function BookstrContent({ wikilink, className }: BookstrContentProps) {
}) })
: section.events : section.events
const isExpanded = expandedSections.has(sectionIndex)
const hasVerses = section.originalVerses !== undefined && section.originalVerses.length > 0
const isLast = sectionIndex === sections.length - 1 const isLast = sectionIndex === sections.length - 1
const cardHeight = cardHeights.get(sectionIndex) || 0
const isCardCollapsed = collapsedCards.has(sectionIndex)
const needsCollapse = cardHeight > 500
// Only show button if card is actually tall (needs collapse) or is currently collapsed
const shouldShowButton = filteredEvents.length > 0 && (needsCollapse || isCardCollapsed)
// Check if this section is still loading // Check if this section is still loading
const refKey = `${section.reference.book}-${section.reference.chapter}-${section.reference.verse}` const refKey = `${section.reference.book}-${section.reference.chapter}-${section.reference.verse}`
const isSectionLoading = loadingSections.has(refKey) const isSectionLoading = loadingSections.has(refKey)
// Debug logging
if (filteredEvents.length > 0) {
logger.debug('BookstrContent: Card collapse check', {
sectionIndex,
eventCount: filteredEvents.length,
cardHeight,
isCardCollapsed,
needsCollapse,
shouldShowButton
})
}
return ( return (
<React.Fragment key={sectionIndex}> <React.Fragment key={sectionIndex}>
<div <div
ref={(el) => {
if (el) {
cardRefs.current.set(sectionIndex, el)
} else {
cardRefs.current.delete(sectionIndex)
}
}}
className={cn( className={cn(
'p-3', 'p-3',
!isLast && 'border-b', !isLast && 'border-b'
needsCollapse && isCardCollapsed && 'overflow-hidden'
)} )}
style={needsCollapse && isCardCollapsed ? {
maxHeight: '500px',
transition: 'max-height 0.3s ease-out'
} : undefined}
> >
{/* Header */} {/* Header */}
<div className="flex items-center justify-between gap-2 mb-2"> <div className="flex items-center justify-between gap-2 mb-2">
@ -903,92 +804,14 @@ export function BookstrContent({ wikilink, className }: BookstrContentProps) {
</Button> </Button>
</div> </div>
{/* Verses */} {/* Verses - render all verses together, including ranges */}
{filteredEvents.length > 0 && ( {filteredEvents.length > 0 && (
<VerseContent <VerseContent
events={filteredEvents} events={filteredEvents}
/>
)}
</div>
{/* Show more/less button for tall cards - OUTSIDE collapsed div so it's always visible */}
{shouldShowButton ? (
<div className="px-3 pb-3 border-t pt-2">
<Button
variant="ghost"
size="sm"
className="h-6 text-xs w-full"
onClick={() => {
setCollapsedCards(prev => {
const newSet = new Set(prev)
if (newSet.has(sectionIndex)) {
newSet.delete(sectionIndex)
} else {
newSet.add(sectionIndex)
}
return newSet
})
}}
>
{isCardCollapsed ? (
<>
<ChevronDown className="h-3 w-3 mr-1" />
Show more
</>
) : (
<>
<ChevronUp className="h-3 w-3 mr-1" />
Show less
</>
)}
</Button>
</div>
) : null}
{/* Expand/Collapse buttons - only show if events were found */}
{hasVerses && filteredEvents.length > 0 && (
<div className="px-3 pb-3">
<Button
variant="ghost"
size="sm"
className="mt-2 h-6 text-xs"
onClick={() => {
const newExpanded = new Set(expandedSections)
if (newExpanded.has(sectionIndex)) {
newExpanded.delete(sectionIndex)
} else {
newExpanded.add(sectionIndex)
}
setExpandedSections(newExpanded)
}}
>
{isExpanded ? (
<>
<ChevronUp className="h-3 w-3 mr-1" />
Collapse chapter
</>
) : (
<>
<ChevronDown className="h-3 w-3 mr-1" />
Read full chapter
</>
)}
</Button>
</div>
)}
{/* Expanded content */}
{isExpanded && (
<div className="px-3 pb-3 mt-3 pt-3 border-t">
{/* Fetch and display full chapter/book */}
<ExpandedContent
section={section}
selectedVersion={selectedVersion}
originalChapter={section.originalChapter}
originalVerses={section.originalVerses} originalVerses={section.originalVerses}
/> />
</div>
)} )}
</div>
</React.Fragment> </React.Fragment>
) )
})} })}
@ -997,69 +820,13 @@ export function BookstrContent({ wikilink, className }: BookstrContentProps) {
) )
} }
interface ExpandedContentProps { interface VerseContentProps {
section: BookSection events: Event[]
selectedVersion: string
originalChapter?: number
originalVerses?: string originalVerses?: string
} }
function ExpandedContent({ section, selectedVersion, originalChapter, originalVerses }: ExpandedContentProps) { function VerseContent({ events, originalVerses }: VerseContentProps) {
const [expandedEvents, setExpandedEvents] = useState<Event[]>([]) const [parsedContents, setParsedContents] = useState<Map<string, string>>(new Map())
const [isLoading, setIsLoading] = useState(true)
useEffect(() => {
const fetchExpanded = async () => {
setIsLoading(true)
try {
// Determine book type (default to bible)
const bookType = 'bible' // Could be extracted from section if we store it
const normalizedBook = section.reference.book.toLowerCase().replace(/\s+/g, '-')
// Fetch full chapter or book
const filters: any = {
type: bookType,
book: normalizedBook
}
if (originalChapter !== undefined) {
// Fetch full chapter
filters.chapter = originalChapter
}
// If no chapter specified, fetch entire book
if (selectedVersion) {
filters.version = selectedVersion.toLowerCase()
}
const events = await client.fetchBookstrEvents(filters)
// Sort by chapter and verse
events.sort((a, b) => {
const aMeta = extractBookMetadata(a)
const bMeta = extractBookMetadata(b)
const aChapter = parseInt(aMeta.chapter || '0')
const bChapter = parseInt(bMeta.chapter || '0')
if (aChapter !== bChapter) return aChapter - bChapter
const aVerse = parseInt(aMeta.verse || '0')
const bVerse = parseInt(bMeta.verse || '0')
return aVerse - bVerse
})
setExpandedEvents(events)
} catch (err) {
logger.error('Error fetching expanded content', { error: err })
} finally {
setIsLoading(false)
}
}
fetchExpanded()
}, [section, selectedVersion, originalChapter])
if (isLoading) {
return <div className="text-xs text-muted-foreground">Loading...</div>
}
// Parse original verses to determine which ones should have a border // Parse original verses to determine which ones should have a border
const originalVerseNumbers = new Set<number>() const originalVerseNumbers = new Set<number>()
@ -1067,6 +834,7 @@ function ExpandedContent({ section, selectedVersion, originalChapter, originalVe
const verseSpecs = originalVerses.split(',').map(v => v.trim()).filter(v => v) const verseSpecs = originalVerses.split(',').map(v => v.trim()).filter(v => v)
for (const spec of verseSpecs) { for (const spec of verseSpecs) {
if (spec.includes('-')) { if (spec.includes('-')) {
// Expand range like "16-18" into 16, 17, 18
const [startStr, endStr] = spec.split('-').map(v => v.trim()) const [startStr, endStr] = spec.split('-').map(v => v.trim())
const start = parseInt(startStr) const start = parseInt(startStr)
const end = parseInt(endStr) const end = parseInt(endStr)
@ -1084,22 +852,6 @@ function ExpandedContent({ section, selectedVersion, originalChapter, originalVe
} }
} }
return (
<VerseContent
events={expandedEvents}
originalVerseNumbers={originalVerseNumbers}
/>
)
}
interface VerseContentProps {
events: Event[]
originalVerseNumbers?: Set<number>
}
function VerseContent({ events, originalVerseNumbers }: VerseContentProps) {
const [parsedContents, setParsedContents] = useState<Map<string, string>>(new Map())
useEffect(() => { useEffect(() => {
const parseAll = async () => { const parseAll = async () => {
const newParsed = new Map<string, string>() const newParsed = new Map<string, string>()
@ -1132,7 +884,7 @@ function VerseContent({ events, originalVerseNumbers }: VerseContentProps) {
const metadata = extractBookMetadata(event) const metadata = extractBookMetadata(event)
const verseNum = metadata.verse const verseNum = metadata.verse
const verseNumInt = verseNum ? parseInt(verseNum) : null const verseNumInt = verseNum ? parseInt(verseNum) : null
const isOriginalVerse = originalVerseNumbers && verseNumInt !== null && originalVerseNumbers.has(verseNumInt) const isOriginalVerse = originalVerseNumbers.size > 0 && verseNumInt !== null && originalVerseNumbers.has(verseNumInt)
const content = parsedContents.get(event.id) || event.content const content = parsedContents.get(event.id) || event.content
return ( return (

46
src/lib/bookstr-parser.ts
Unescape View File

@ -80,8 +80,17 @@ export function parseBookWikilink(wikilink: string): { references: BookReference
versionPart = pipeParts[pipeParts.length - 1].trim() versionPart = pipeParts[pipeParts.length - 1].trim()
} }
// Parse title, chapter, section from titlePart // Parse versions first (needed for references)
const chapterSectionMatch = titlePart.match(/^(.+?)\s+(\d+|[a-zA-Z0-9_-]+)(?::(.+))?$/) const versions = versionPart ? versionPart.split(/\s+/).map(v => normalizeNip54(v).toUpperCase()).filter(v => v) : undefined
// Parse multiple references from titlePart (e.g., "romans 1:16-17, psalms 23:1")
// Split by comma to handle multiple book references
const referenceStrings = titlePart.split(',').map(s => s.trim()).filter(s => s)
const references: BookReference[] = []
for (const refString of referenceStrings) {
// Parse each reference: "book chapter:verse" or "book chapter" or "book"
const chapterSectionMatch = refString.match(/^(.+?)\s+(\d+|[a-zA-Z0-9_-]+)(?::(.+))?$/)
let title = '' let title = ''
let chapter: number | undefined let chapter: number | undefined
@ -95,16 +104,9 @@ export function parseBookWikilink(wikilink: string): { references: BookReference
verse = chapterSectionMatch[3].trim() verse = chapterSectionMatch[3].trim()
} }
} else { } else {
title = normalizeNip54(titlePart) title = normalizeNip54(refString)
} }
// Parse versions
const versions = versionPart ? versionPart.split(/\s+/).map(v => normalizeNip54(v).toUpperCase()).filter(v => v) : undefined
// Use collection as bookType (e.g., "bible", "quran", "torah")
// If no collection, default to "bible"
const inferredBookType = collection || 'bible'
// Create reference // Create reference
const reference: BookReference = { const reference: BookReference = {
book: title book: title
@ -119,11 +121,19 @@ export function parseBookWikilink(wikilink: string): { references: BookReference
reference.version = versions[0] // Use first version for backward compatibility reference.version = versions[0] // Use first version for backward compatibility
} }
return { references: [reference], versions, bookType: inferredBookType } references.push(reference)
}
// Use collection as bookType (e.g., "bible", "quran", "torah")
// If no collection, default to "bible"
const inferredBookType = collection || 'bible'
return { references, versions, bookType: inferredBookType }
} }
/** /**
* Extract book metadata from event tags * Extract book metadata from event tags
* Tags: C (collection), T (title), c (chapter), s (section), v (version)
*/ */
export function extractBookMetadata(event: { tags: string[][] }): { export function extractBookMetadata(event: { tags: string[][] }): {
type?: string type?: string
@ -136,19 +146,23 @@ export function extractBookMetadata(event: { tags: string[][] }): {
for (const [tag, value] of event.tags) { for (const [tag, value] of event.tags) {
switch (tag) { switch (tag) {
case 'type': case 'C': // Collection
metadata.type = value metadata.type = value
break break
case 'book': case 'T': // Title (book name)
metadata.book = value metadata.book = value
break break
case 'chapter': case 'c': // Chapter
metadata.chapter = value metadata.chapter = value
break break
case 'verse': case 's': // Section
// Section might be used for verse or other metadata
// If we don't have verse yet, use section as verse
if (!metadata.verse) {
metadata.verse = value metadata.verse = value
}
break break
case 'version': case 'v': // Version
metadata.version = value metadata.version = value
break break
} }

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

@ -2474,13 +2474,25 @@ class ClientService extends EventTarget {
let events: NEvent[] = [] let events: NEvent[] = []
try { try {
// Query ONLY 30040s (publications/indexes) by pubkey and kind // Query ONLY 30040s (publications/indexes) by pubkey and kind with precise tag filters
const publicationFilter: Filter = { const publicationFilter: Filter = {
authors: [publicationPubkey], authors: [publicationPubkey],
kinds: [ExtendedKind.PUBLICATION], kinds: [ExtendedKind.PUBLICATION],
limit: 500 limit: 500
} }
// Add precise tag filters for collection, title, and chapter
if (filters.type) {
publicationFilter['#C'] = [filters.type.toLowerCase()]
}
if (filters.book) {
const normalizedBook = filters.book.toLowerCase().replace(/\s+/g, '-')
publicationFilter['#T'] = [normalizedBook]
}
if (filters.chapter !== undefined) {
publicationFilter['#c'] = [filters.chapter.toString()]
}
const allPublications = await this.fetchEvents(prioritizedFallbackRelaysWithCitadel, publicationFilter, { const allPublications = await this.fetchEvents(prioritizedFallbackRelaysWithCitadel, publicationFilter, {
eoseTimeout: 5000, eoseTimeout: 5000,
globalTimeout: 8000 globalTimeout: 8000
@ -2536,6 +2548,29 @@ class ClientService extends EventTarget {
if (d) { if (d) {
aTagFilter['#d'] = [d] aTagFilter['#d'] = [d]
} }
// Add all precise tag filters: C (collection), T (title), c (chapter), s (section/verse), v (version)
if (filters.type) {
aTagFilter['#C'] = [filters.type.toLowerCase()]
}
if (filters.book) {
const normalizedBook = filters.book.toLowerCase().replace(/\s+/g, '-')
aTagFilter['#T'] = [normalizedBook]
}
if (filters.chapter !== undefined) {
aTagFilter['#c'] = [filters.chapter.toString()]
}
if (filters.verse) {
// Section tag (s) is used for verse
// For verse ranges, we'll need to expand and query each verse
// For now, just add the first verse if it's a single verse
const verseParts = filters.verse.split(/[,\s-]+/).map(v => v.trim()).filter(v => v)
if (verseParts.length === 1 && !verseParts[0].includes('-')) {
aTagFilter['#s'] = [verseParts[0]]
}
}
if (filters.version) {
aTagFilter['#v'] = [filters.version.toLowerCase()]
}
try { try {
const aTagEvents = await this.fetchEvents(prioritizedFallbackRelaysWithCitadel, aTagFilter, { const aTagEvents = await this.fetchEvents(prioritizedFallbackRelaysWithCitadel, aTagFilter, {
@ -2612,110 +2647,64 @@ class ClientService extends EventTarget {
try { try {
const bookstrPublisherPubkey = '3e1ad0f3a5d3c12245db7788546c43ade3d97c6e046c594f6017cd6cd4164690' const bookstrPublisherPubkey = '3e1ad0f3a5d3c12245db7788546c43ade3d97c6e046c594f6017cd6cd4164690'
// Query ONLY 30040s (publications/indexes) with just type and kind filters // Query BOTH 30040s (publications/indexes) AND 30041s (content) together
// Only use #T (title) and #c (chapter) in relay filter - filter #C, #s, #v client-side
// This matches wikistr's approach and avoids relay compatibility issues
const publicationFilter: Filter = { const publicationFilter: Filter = {
kinds: [ExtendedKind.PUBLICATION], kinds: [ExtendedKind.PUBLICATION, ExtendedKind.PUBLICATION_CONTENT],
authors: [bookstrPublisherPubkey], authors: [bookstrPublisherPubkey],
limit: 500 limit: 500
} }
// Only add #type filter if we have a type // Only add #T (title) and #c (chapter) filters - filter rest client-side
if (filters.type) { if (filters.book) {
publicationFilter['#type'] = [filters.type.toLowerCase()] // Normalize book name: lowercase, replace spaces with hyphens (NIP-54 style)
// The parser already normalized it, but ensure consistency
const normalizedBook = filters.book.toLowerCase().replace(/\s+/g, '-')
publicationFilter['#T'] = [normalizedBook]
}
if (filters.chapter !== undefined) {
publicationFilter['#c'] = [filters.chapter.toString()]
} }
// Don't include #C, #s, or #v in relay filter - filter client-side instead
const publisherPublications = await this.fetchEvents(prioritizedFallbackRelays, publicationFilter, { const publisherPublications = await this.fetchEvents(prioritizedFallbackRelays, publicationFilter, {
eoseTimeout: 5000, eoseTimeout: 5000,
globalTimeout: 8000 globalTimeout: 8000
}) })
logger.info('fetchBookstrEventsFromRelays: Fetched 30040 publications', { logger.info('fetchBookstrEventsFromRelays: Fetched events', {
count: publisherPublications.length, count: publisherPublications.length,
filters: JSON.stringify(filters) filters: JSON.stringify(filters)
}) })
// Filter 30040s client-side to find matching book/chapter // Filter ALL events (both 30040 and 30041) client-side
// Note: Don't filter by verse for 30040s - verses are in 30041s // This matches wikistr's approach - filter #C, #s, #v client-side
const matchingPublications = publisherPublications.filter(pub => { const matchingEvents = publisherPublications.filter(event => {
return this.eventMatchesBookstrFilters(pub, filters) return this.eventMatchesBookstrFilters(event, filters)
}) })
logger.info('fetchBookstrEventsFromRelays: Filtered 30040 publications', { logger.info('fetchBookstrEventsFromRelays: Filtered events', {
total: publisherPublications.length, total: publisherPublications.length,
matching: matchingPublications.length, matching: matchingEvents.length,
filters: JSON.stringify(filters) filters: JSON.stringify(filters)
}) })
// For each matching 30040, fetch its a-tagged 30041 events (content) // Separate 30040s (publications) and 30041s (content)
for (const publication of matchingPublications) { // We queried for both kinds, so we get content events directly
const aTags = publication.tags const contentEvents = matchingEvents.filter(e => e.kind === ExtendedKind.PUBLICATION_CONTENT)
.filter(tag => tag[0] === 'a' && tag[1])
.map(tag => tag[1])
logger.info('fetchBookstrEventsFromRelays: Fetching 30041s from matching publication', {
publicationId: publication.id.substring(0, 8),
aTagCount: aTags.length,
filters: JSON.stringify(filters)
})
// Fetch all a-tagged 30041 events in parallel events.push(...contentEvents)
const aTagPromises = aTags.map(async (aTag) => {
const parts = aTag.split(':')
if (parts.length < 2) return null
const kind = parseInt(parts[0]) // Note: We could also process 30040 publications to fetch their a-tagged 30041s,
const pubkey = parts[1] // but since we already queried for 30041s directly, we should have them.
const d = parts[2] || '' // If we need more, we can fetch from 30040 a-tags, but for now this is simpler.
// Only fetch 30041 events (content events)
if (kind !== ExtendedKind.PUBLICATION_CONTENT) {
return null
}
const aTagFilter: Filter = {
authors: [pubkey],
kinds: [ExtendedKind.PUBLICATION_CONTENT],
limit: 1
}
if (d) {
aTagFilter['#d'] = [d]
}
try {
const aTagEvents = await this.fetchEvents(prioritizedFallbackRelays, aTagFilter, {
eoseTimeout: 3000,
globalTimeout: 5000
})
// Filter 30041s client-side by book, type, version, chapter, verse
return aTagEvents.filter(event => {
return this.eventMatchesBookstrFilters(event, filters)
})
} catch (err) {
logger.debug('fetchBookstrEventsFromRelays: Error fetching a-tag event', {
aTag,
error: err
})
return []
}
})
const aTagResults = await Promise.all(aTagPromises)
const aTagEvents = aTagResults.flat().filter((e): e is NEvent => e !== null)
logger.info('fetchBookstrEventsFromRelays: Fetched 30041s from publication', {
publicationId: publication.id.substring(0, 8),
fetched: aTagEvents.length,
totalSoFar: events.length + aTagEvents.length
})
events.push(...aTagEvents)
}
if (events.length > 0) { if (events.length > 0) {
logger.info('fetchBookstrEventsFromRelays: Successfully fetched content events', { logger.info('fetchBookstrEventsFromRelays: Successfully fetched content events', {
publicationCount: matchingPublications.length, totalQueried: publisherPublications.length,
eventCount: events.length, matchingAfterFilter: matchingEvents.length,
contentEvents: events.length,
filters: JSON.stringify(filters) filters: JSON.stringify(filters)
}) })
return events return events
@ -2865,8 +2854,9 @@ class ClientService extends EventTarget {
if (filters.book) { if (filters.book) {
const normalizedBook = filters.book.toLowerCase().replace(/\s+/g, '-') const normalizedBook = filters.book.toLowerCase().replace(/\s+/g, '-')
// Get ALL book tags from the event (events can have multiple book tags) // Get ALL book tags from the event (events can have multiple book tags)
// Check 'T' (title/book) tags
const eventBookTags = event.tags const eventBookTags = event.tags
.filter(tag => tag[0] === 'book' && tag[1]) .filter(tag => tag[0] === 'T' && tag[1])
.map(tag => tag[1].toLowerCase()) .map(tag => tag[1].toLowerCase())
// Check if any of the book tags match // Check if any of the book tags match
@ -3393,6 +3383,7 @@ class ClientService extends EventTarget {
/** /**
* Extract book metadata from event tags (helper method) * Extract book metadata from event tags (helper method)
* Tags: C (collection), T (title), c (chapter), s (section), v (version)
*/ */
private extractBookMetadataFromEvent(event: NEvent): { private extractBookMetadataFromEvent(event: NEvent): {
type?: string type?: string
@ -3404,19 +3395,23 @@ class ClientService extends EventTarget {
const metadata: any = {} const metadata: any = {}
for (const [tag, value] of event.tags) { for (const [tag, value] of event.tags) {
switch (tag) { switch (tag) {
case 'type': case 'C': // Collection
metadata.type = value metadata.type = value
break break
case 'book': case 'T': // Title (book name)
metadata.book = value metadata.book = value
break break
case 'chapter': case 'c': // Chapter
metadata.chapter = value metadata.chapter = value
break break
case 'verse': case 's': // Section
// Section might be used for verse or other metadata
// If we don't have verse yet, use section as verse
if (!metadata.verse) {
metadata.verse = value metadata.verse = value
}
break break
case 'version': case 'v': // Version
metadata.version = value metadata.version = value
break break
} }

Write Preview
Loading…
Cancel
Save