FilesExpand file tree

main

/

index-list.ts

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

69 lines (61 loc) · 2.58 KB

main

/

index-list.ts

Copy path

Top

File metadata and controls

• Code
• Blame

69 lines (61 loc) · 2.58 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

import type { ContentMeta } from '@/lib/content/schema'

export const POSTS_PER_PAGE = 20

export const FEATURED_COUNT = 3

interface PaginatedContentPosts {

featured: ContentMeta[]

remaining: ContentMeta[]

totalPages: number

}

/**

* Reproduces `ContentIndexPage`'s render logic for a given `tag`/`page`

* combination: tag-filtered, date-sorted, with up to `FEATURED_COUNT`

* featured posts (explicit `post.featured` first, falling back to the most

* recent) carved out of the paginated pool and returned only on page 1.

* Shared by `ContentIndexPage` itself and `selectVisiblePosts` below, so

* every consumer stays in lockstep with what's actually rendered.

*/

export function paginateContentPosts(

posts: ContentMeta[],

{ tag, page }: { tag?: string; page: number }

): PaginatedContentPosts {

const filtered = tag ? posts.filter((p) => p.tags.includes(tag)) : posts

const dateSorted = [...filtered].sort(

(a, b) => new Date(b.date).getTime() - new Date(a.date).getTime()

)

const explicitlyFeatured = dateSorted.filter((p) => p.featured).slice(0, FEATURED_COUNT)

const featuredPosts =

explicitlyFeatured.length > 0 ? explicitlyFeatured : dateSorted.slice(0, FEATURED_COUNT)

const featuredSlugs = new Set(featuredPosts.map((p) => p.slug))

const paginated = dateSorted.filter((p) => !featuredSlugs.has(p.slug))

const totalPages = Math.max(1, Math.ceil(paginated.length / POSTS_PER_PAGE))

const start = (page - 1) * POSTS_PER_PAGE

return {

featured: page === 1 ? featuredPosts : [],

remaining: paginated.slice(start, start + POSTS_PER_PAGE),

totalPages,

}

}

/**

* Flat, render-order post list (featured then remaining) for a given

* `tag`/`page` combination - used to keep `buildCollectionPageJsonLd`'s

* `mainEntity` ItemList in sync with the posts actually visible on a

* filtered or paginated index URL, instead of the full unfiltered catalog.

*/

export function selectVisiblePosts(

posts: ContentMeta[],

options: { tag?: string; page: number }

): ContentMeta[] {

const { featured, remaining } = paginateContentPosts(posts, options)

return [...featured, ...remaining]

}

/** Resolves an archive page number, rejecting invalid or empty pagination URLs. */

export function resolveContentPage(

posts: ContentMeta[],

{ tag, page }: { tag?: string; page?: string }

): number | null {

if (page !== undefined && !/^[1-9]\d*$/.test(page)) return null

const pageNum = Number(page ?? 1)

if (!Number.isSafeInteger(pageNum)) return null

const { totalPages } = paginateContentPosts(posts, { tag, page: pageNum })

return pageNum <= totalPages ? pageNum : null

}