@meith/web 0.16.0

package/app/(board)/online/page.tsx

@@ -0,0 +1,119 @@
+import type { Metadata } from 'next'
+
+import { Card, CardFooter, CardRows, Empty, EmptyDescription, EmptyTitle } from '@meith/ui'
+
+import { PanelPage } from '@/components/shell/panel-page'
+import { getActor } from '@/server/context'
+import { identitiesFor } from '@/server/group-identity'
+import { getTranslator, tr } from '@/server/i18n'
+import { presenceRepository, readOnline } from '@/server/presence'
+import { locationOf } from '@/view/presence'
+import { formatTime } from '@/view/time'
+
+export async function generateMetadata(): Promise<Metadata> {
+  return { title: await tr('page.who-s-online') }
+}
+
+export default async function OnlinePage() {
+  const actor = await getActor()
+  const now = new Date()
+  const translator = await getTranslator()
+
+  const snapshot = await readOnline(actor, now)
+  const repo = presenceRepository()
+  const record = repo === null ? { count: 0, at: null } : await repo.readRecord()
+
+  if (snapshot === null) {
+    return (
+      <PanelPage frame="standalone" title={await tr('page.who-s-online')}>
+        <Card>
+          <Empty>
+            <EmptyTitle>{await tr('page.nobody-counted-here')}</EmptyTitle>
+            <EmptyDescription>{await tr('page.this-board-not-tracking-who')}</EmptyDescription>
+          </Empty>
+        </Card>
+      </PanelPage>
+    )
+  }
+
+  const identities = await identitiesFor(snapshot.members.map((member) => member.userId))
+
+  return (
+    <PanelPage
+      frame="standalone"
+      title={await tr('page.who-s-online')}
+      lede={
+        <>
+          {translator.t('presence.summary', {
+            total: snapshot.total,
+            members: snapshot.members.length,
+            guests: snapshot.guestCount,
+          })}
+          {snapshot.invisibleCount > 0 &&
+            ` ${translator.t('presence.invisible', { count: snapshot.invisibleCount })}`}
+        </>
+      }
+    >
+      <Card>
+        {snapshot.members.length === 0 ? (
+          <Empty>
+            <EmptyTitle>{await tr('page.nobody-here')}</EmptyTitle>
+            <EmptyDescription>{await tr('page.no-members-online-right-now')}</EmptyDescription>
+          </Empty>
+        ) : (
+          <CardRows>
+            {snapshot.members.map((member) => {
+              const where = locationOf(member, translator)
+              return (
+                <li
+                  key={member.userId}
+                  className="flex flex-col gap-1 px-4 py-3 sm:flex-row sm:items-baseline sm:justify-between sm:gap-4"
+                >
+                  <span className="text-sm font-medium">
+                    <a
+                      href={`/member/${member.userId}`}
+                      className={`font-medium text-foreground underline decoration-border underline-offset-2 hover:decoration-foreground ${
+                        identities.get(member.userId)?.nameClass ?? ''
+                      }`}
+                    >
+                      {member.username}
+                    </a>
+                    {member.invisible && (
+                      <span className="ml-1 text-xs text-muted-foreground">
+                        {translator.t('board.online.invisible')}
+                      </span>
+                    )}
+                  </span>
+
+                  <span className="text-xs text-muted-foreground">
+                    {where.href === null ? (
+                      where.label
+                    ) : (
+                      <a href={where.href} className="hover:underline">
+                        {where.label}
+                      </a>
+                    )}
+                    {' · '}
+                    <time dateTime={member.lastSeenAt.toISOString()}>
+                      {formatTime(member.lastSeenAt, now, translator).label}
+                    </time>
+                  </span>
+                </li>
+              )
+            })}
+          </CardRows>
+        )}
+
+        {record.at !== null && (
+          <CardFooter>
+            {translator.t('board.online.record', { count: record.count })}{' '}
+            <time dateTime={record.at.toISOString()}>
+              {formatTime(record.at, now, translator).label}
+            </time>
+            .
+          </CardFooter>
+        )}
+      </Card>
+    </PanelPage>
+  )
+}

package/app/(board)/page.tsx

@@ -0,0 +1,195 @@
+import type { Metadata } from 'next'
+
+import { requireSlot, slotCopy } from '@meith/theme-kit'
+
+import { LiveRegion } from '@/components/board/live-region'
+import { liveAnnouncements } from '@/server/announcements'
+import { LATEST_REFRESH_SECONDS, renderLatestPanels } from '@/server/board-latest'
+import { refreshLatestPanels } from '@/server/board-latest-actions'
+import { getContainer } from '@/server/container'
+import { getActor } from '@/server/context'
+import { identitiesFor } from '@/server/group-identity'
+import { getTranslator, tr } from '@/server/i18n'
+import { boardRegion, filterView, viewerRef } from '@/server/plugin-view'
+import { presenceRepository, readOnline } from '@/server/presence'
+import { readTotals } from '@/server/stats'
+import { currentTheme } from '@/server/theme'
+import { getViewerPreferences } from '@/server/viewer-preferences'
+import { buildBoardIndexView } from '@/view/board-index'
+import { distinctUserIds } from '@/view/member-identity'
+import { buildBoardStatsModel, buildWhoIsOnlineModel } from '@/view/presence'
+
+export async function generateMetadata(): Promise<Metadata> {
+  return { title: await tr('page.forums') }
+}
+
+export default async function BoardIndexPage() {
+  const actor = await getActor()
+  const { forums, authorizer, readState } = getContainer()
+
+  const [rows, listing, read, _preferences] = await Promise.all([
+    forums.listListing(),
+    authorizer.listingVisibility(actor),
+    actor.userId === null || readState === null
+      ? Promise.resolve(null)
+      : readState.forUser(actor.userId),
+    getViewerPreferences(),
+  ])
+
+  const now = new Date()
+
+  const translator = await getTranslator()
+  const [online, totals, record, latest] = await Promise.all([
+    readOnline(actor, now),
+    readTotals(),
+    presenceRepository()?.readRecord() ?? Promise.resolve({ count: 0, at: null }),
+    renderLatestPanels(),
+  ])
+
+  const identities = await identitiesFor(
+    distinctUserIds([
+      ...rows.map((row) => row.lastPost?.userId ?? null),
+      totals?.newestUserId ?? null,
+      ...(online?.members ?? []).map((member) => member.userId),
+    ]),
+  )
+
+  const view = buildBoardIndexView({
+    rows,
+    visibleForumIds: new Set(listing.visibleForumIds),
+    ownThreadsOnlyForumIds: new Set(listing.ownThreadsOnlyForumIds),
+    ...(read === null ? {} : { unreadForumIds: read.unreadForumIds }),
+    markAllReadAction: read === null ? null : '/api/read/all',
+    now,
+    t: translator,
+    identities,
+  })
+
+  const announcements = await liveAnnouncements({
+    visibleForumIds: listing.visibleForumIds,
+    now,
+    t: translator,
+  })
+
+  const theme = await currentTheme()
+  const Announcement = requireSlot(theme, 'Announcement')
+  const BoardIndex = requireSlot(theme, 'BoardIndex')
+  const CategoryBlock = requireSlot(theme, 'CategoryBlock')
+  const ForumRow = requireSlot(theme, 'ForumRow')
+  const BoardStats = requireSlot(theme, 'BoardStats')
+  const WhoIsOnline = requireSlot(theme, 'WhoIsOnline')
+
+  const pluginContext = viewerRef(actor)
+
+  const filteredAnnouncements = await Promise.all(
+    announcements.map((announcement) =>
+      filterView('view.announcement', announcement, pluginContext),
+    ),
+  )
+
+  const blocks = await Promise.all(
+    view.blocks.map(async (entry) => ({
+      block: await filterView(
+        'view.category-block',
+        { category: entry.block.category },
+        pluginContext,
+      ),
+      forums: await Promise.all(
+        entry.forums.map((forum) => filterView('view.forum-row', { forum }, pluginContext)),
+      ),
+    })),
+  )
+
+  const stats =
+    totals === null
+      ? null
+      : await filterView(
+          'view.board-stats',
+          buildBoardStatsModel({
+            ...totals,
+            now,
+            t: translator,
+            identities,
+          }),
+          pluginContext,
+        )
+
+  const whoIsOnline =
+    online === null
+      ? null
+      : await filterView(
+          'view.who-is-online',
+          buildWhoIsOnlineModel({
+            members: online.members,
+            guestCount: online.guestCount,
+            recordCount: record.count,
+            recordAt: record.at,
+            now,
+            t: translator,
+            identities,
+          }),
+          pluginContext,
+        )
+
+  const index = await filterView(
+    'view.board-index',
+    {
+      ...view.index,
+      regions: {
+        categories: blocks.map((entry) => (
+          <CategoryBlock
+            key={entry.block.category.id}
+            {...entry.block}
+            copy={slotCopy(theme, 'CategoryBlock', translator)}
+          >
+            {entry.forums.map((row) => (
+              <ForumRow
+                key={row.forum.id}
+                {...row}
+                copy={slotCopy(theme, 'ForumRow', translator)}
+              />
+            ))}
+          </CategoryBlock>
+        )),
+        stats:
+          stats === null ? null : (
+            <BoardStats {...stats} copy={slotCopy(theme, 'BoardStats', translator)} />
+          ),
+        online:
+          whoIsOnline === null ? null : (
+            <WhoIsOnline {...whoIsOnline} copy={slotCopy(theme, 'WhoIsOnline', translator)} />
+          ),
+        latest:
+          latest === null ? null : (
+            <LiveRegion
+              refresh={refreshLatestPanels}
+              seconds={LATEST_REFRESH_SECONDS}
+              label={translator.t('board.index.latestActivity')}
+            >
+              {latest}
+            </LiveRegion>
+          ),
+        plugins: await boardRegion('index.footer', actor),
+        ...(announcements.length === 0
+          ? {}
+          : {
+              announcements: filteredAnnouncements.map((announcement, position) => (
+                <Announcement
+                  // biome-ignore lint/suspicious/noArrayIndexKey: the position is the identity — this list is server-rendered in order and never reordered on the client
+                  key={position}
+                  {...announcement}
+                  copy={slotCopy(theme, 'Announcement', translator)}
+                />
+              )),
+            }),
+      },
+    },
+    pluginContext,
+  )
+
+  return (
+    <main id="board-content" tabIndex={-1} className="flex-1">
+      <BoardIndex {...index} copy={slotCopy(theme, 'BoardIndex', translator)} />
+    </main>
+  )
+}

package/app/(board)/plugins/[key]/[[...path]]/page.tsx

@@ -0,0 +1,72 @@
+import type { Metadata } from 'next'
+import { notFound, redirect } from 'next/navigation'
+
+import { pluginPagePath } from '@meith/plugin-kit'
+
+import { boardUrl } from '@/server/board-url'
+import { getActor } from '@/server/context'
+import { getTranslator } from '@/server/i18n'
+import { pluginBoardPageTitle, renderPluginBoardPage } from '@/server/plugin-pages'
+import { viewerRef } from '@/server/plugin-view'
+
+interface RouteParams {
+  readonly key: string
+  readonly path?: string[]
+}
+
+export async function generateMetadata({
+  params,
+}: {
+  params: Promise<RouteParams>
+}): Promise<Metadata> {
+  const { key, path } = await params
+  const title = pluginBoardPageTitle(key, (path ?? []).join('/'))
+  return title === null ? {} : { title }
+}
+
+export default async function PluginBoardPage({
+  params,
+  searchParams,
+}: {
+  params: Promise<RouteParams>
+  searchParams: Promise<Record<string, string | string[] | undefined>>
+}) {
+  const { key, path } = await params
+  const segments = path ?? []
+  if (segments.length > 1) notFound()
+  const pagePath = segments.join('/')
+
+  const query: Record<string, string> = {}
+  for (const [name, value] of Object.entries(await searchParams)) {
+    if (typeof value === 'string') query[name] = value
+  }
+
+  const actor = await getActor()
+  const result = await renderPluginBoardPage(key, pagePath, {
+    viewer: viewerRef(actor),
+    query,
+    boardUrl: await boardUrl(),
+  })
+
+  if (result.outcome === 'missing') notFound()
+  if (result.outcome === 'sign-in-first') {
+    redirect(`/login?next=${encodeURIComponent(pluginPagePath(key, pagePath))}`)
+  }
+
+  return (
+    <main
+      id="board-content"
+      tabIndex={-1}
+      className="mx-auto flex w-full max-w-4xl flex-col gap-6 px-6 py-8 flex-1"
+    >
+      <h1 className="font-heading text-2xl font-semibold">{result.title}</h1>
+      {result.node === null ? (
+        <p className="rounded-lg border border-border p-4 text-sm text-muted-foreground">
+          {(await getTranslator()).t('board.plugin.failed')}
+        </p>
+      ) : (
+        result.node
+      )}
+    </main>
+  )
+}

package/app/(board)/privacy/page.tsx

@@ -0,0 +1,12 @@
+import type { Metadata } from 'next'
+
+import { LegalDocument } from '@/components/legal/legal-document'
+import { tr } from '@/server/i18n'
+
+export async function generateMetadata(): Promise<Metadata> {
+  return { title: await tr('page.privacy-policy') }
+}
+
+export default async function PrivacyPage() {
+  return <LegalDocument slug="privacy" />
+}

package/app/(board)/report/page.tsx

@@ -0,0 +1,71 @@
+import type { Metadata } from 'next'
+import { notFound } from 'next/navigation'
+
+import { parseTargetKind } from '@meith/moderation'
+
+import { ReportForm } from '@/components/moderation/report-forms'
+import { PanelPage } from '@/components/shell/panel-page'
+import { getContainer } from '@/server/container'
+import { getActor } from '@/server/context'
+import { getTranslator, tr } from '@/server/i18n'
+import { moderationFormsCopy } from '@/view/moderation-copy'
+
+export async function generateMetadata(): Promise<Metadata> {
+  return { title: await tr('page.report') }
+}
+
+function positiveInt(value: string | undefined): number | null {
+  if (value === undefined || !/^[1-9]\d*$/.test(value)) return null
+  const id = Number(value)
+  return Number.isSafeInteger(id) ? id : null
+}
+
+export default async function ReportPage({
+  searchParams,
+}: {
+  searchParams: Promise<{ kind?: string; id?: string }>
+}) {
+  const query = await searchParams
+  const kind = parseTargetKind(query.kind)
+  const targetId = positiveInt(query.id)
+  if (kind === null || targetId === null) notFound()
+
+  const actor = await getActor()
+  const { authorizer, reports } = getContainer()
+  if (reports === null || actor.userId === null) notFound()
+  if (!authorizer.can(actor, 'content.report')) notFound()
+
+  const target = await reports.resolveTarget(kind, targetId, actor.userId)
+  if (target === null) notFound()
+  if (target.forumId !== null) {
+    const matrix = await authorizer.forumMatrix(actor, target.forumId)
+    const scope = {
+      ...(await authorizer.moderatorTargetIn(actor, target.forumId, matrix)),
+      threadAuthorId: target.threadAuthorUserId,
+    }
+    if (!authorizer.can(actor, 'thread.view', scope)) {
+      notFound()
+    }
+  }
+
+  const what =
+    kind === 'user'
+      ? `the member ${target.label}`
+      : kind === 'private_message'
+        ? `the private message “${target.label}”`
+        : `“${target.label}”`
+
+  return (
+    <PanelPage
+      frame="standalone"
+      title={`Report ${what}`}
+      lede={await tr('page.moderator-will-look-at-this')}
+    >
+      <ReportForm
+        kind={kind}
+        targetId={targetId}
+        copy={moderationFormsCopy(await getTranslator())}
+      />
+    </PanelPage>
+  )
+}

package/app/(board)/rules/page.tsx

@@ -0,0 +1,12 @@
+import type { Metadata } from 'next'
+
+import { LegalDocument } from '@/components/legal/legal-document'
+import { tr } from '@/server/i18n'
+
+export async function generateMetadata(): Promise<Metadata> {
+  return { title: await tr('page.rules-faq') }
+}
+
+export default async function RulesPage() {
+  return <LegalDocument slug="rules" />
+}

package/app/(board)/search/[token]/page.tsx

@@ -0,0 +1,130 @@
+import type { Metadata } from 'next'
+import { notFound } from 'next/navigation'
+
+import { isAppError } from '@meith/core'
+import { requireSlot, slotCopy } from '@meith/theme-kit'
+
+import { SearchOffNotice } from '@/components/board/search-off-notice'
+import { getContainer } from '@/server/container'
+import { activeWordFilter } from '@/server/content-admin'
+import { getActor } from '@/server/context'
+import { getTranslator, tr } from '@/server/i18n'
+import { filterView, viewerRef } from '@/server/plugin-view'
+import { searchEnabled } from '@/server/search'
+import { openSearch, readRefinement, SEARCH_COUNT_CAP, SEARCH_PAGE } from '@/server/search-page'
+import { currentSessionKey } from '@/server/session-key'
+import { currentTheme } from '@/server/theme'
+import { buildOffsetPager, offsetOf, readPage } from '@/view/pager'
+import { CURSOR_FIELDS } from '@/view/search-controls'
+import { buildSearchResultsView, type SearchForumRef } from '@/view/search-results'
+
+export async function generateMetadata(): Promise<Metadata> {
+  return { title: await tr('page.search-results') }
+}
+
+export default async function SearchResultsPage({
+  params,
+  searchParams,
+}: {
+  params: Promise<{ token: string }>
+  searchParams: Promise<Record<string, string | string[] | undefined>>
+}) {
+  if (!(await searchEnabled())) {
+    const translator = await getTranslator()
+    return (
+      <SearchOffNotice
+        title={translator.t('board.search.title')}
+        message={translator.t('board.search.disabled')}
+      />
+    )
+  }
+
+  const { token } = await params
+  const query = await searchParams
+
+  const one = (key: string): string | undefined => {
+    const raw = query[key]
+    const text = Array.isArray(raw) ? raw[0] : raw
+    return text === undefined || text === '' ? undefined : text
+  }
+
+  const rank = Number(one(CURSOR_FIELDS.rank))
+  const postId = Number(one(CURSOR_FIELDS.after))
+  const after =
+    Number.isFinite(rank) && Number.isSafeInteger(postId) && postId > 0 ? { rank, postId } : null
+
+  const pageNumber = readPage(query)
+
+  const actor = await getActor()
+  const now = new Date()
+
+  let view: Awaited<ReturnType<typeof openSearch>>
+  try {
+    view = await openSearch({
+      actor,
+      sessionKey: await currentSessionKey(),
+      token,
+      after,
+      offset: offsetOf(pageNumber, SEARCH_PAGE),
+      refine: readRefinement(query),
+      now,
+    })
+  } catch (err) {
+    if (isAppError(err)) notFound()
+    throw err
+  }
+
+  const { search, results, summary, filters, effective, refine } = view
+  const translator = await getTranslator()
+
+  const model = buildSearchResultsView({
+    token,
+    terms: search.terms,
+    createdAt: search.createdAt,
+    hits: results.hits,
+    nextCursor: results.nextCursor,
+    pageSize: SEARCH_PAGE,
+    now,
+    t: translator,
+    filters,
+    effective,
+    refine,
+    summary,
+    forums: await namedForums(),
+    countCap: SEARCH_COUNT_CAP,
+    wordFilter: await activeWordFilter(),
+  })
+
+  const SearchResults = requireSlot(await currentTheme(), 'SearchResults')
+  const Pagination = requireSlot(await currentTheme(), 'Pagination')
+
+  const pager = buildOffsetPager({
+    path: `/search/${token}`,
+    params: query,
+    page: pageNumber,
+    pageSize: SEARCH_PAGE,
+    total: summary.total,
+  })
+
+  const filtered = await filterView('view.search-results', model, viewerRef(actor))
+
+  return (
+    <SearchResults
+      {...filtered}
+      regions={{
+        pagination: (
+          <Pagination
+            {...(await filterView('view.pagination', pager, viewerRef(actor)))}
+            copy={slotCopy(await currentTheme(), 'Pagination', translator)}
+          />
+        ),
+      }}
+      copy={slotCopy(await currentTheme(), 'SearchResults', translator)}
+    />
+  )
+}
+
+async function namedForums(): Promise<readonly SearchForumRef[]> {
+  const { forums } = getContainer()
+  return (await forums.listAll()).map((forum) => ({ id: forum.id, title: forum.title }))
+}