@raystack/chronicle 0.3.0 → 0.5.0

package/src/themes/registry.ts

@@ -1,14 +1,21 @@
-import type { Theme } from '@/types'
-import { defaultTheme } from './default'
-import { paperTheme } from './paper'
+import type { Theme } from '@/types';
+import { defaultTheme } from './default';
+import { paperTheme } from './paper';
 
 const themes: Record<string, Theme> = {
   default: defaultTheme,
-  paper: paperTheme,
-}
+  paper: paperTheme
+};
 
 export function getTheme(name?: string): Theme {
-  if (!name || !themes[name]) return defaultTheme
+  if (!name || !themes[name]) return defaultTheme;
+
+  return themes[name];
+}
 
-  return themes[name]
+export function getThemeConfig(name?: string) {
+  if (name === 'paper') {
+    return { enableSystem: false, forcedTheme: 'light' };
+  }
+  return { enableSystem: true };
 }

package/src/types/config.ts

@@ -1,80 +1,99 @@
-export interface ChronicleConfig {
-  title: string
-  description?: string
-  url?: string
-  logo?: LogoConfig
-  theme?: ThemeConfig
-  navigation?: NavigationConfig
-  search?: SearchConfig
-  footer?: FooterConfig
-  api?: ApiConfig[]
-  llms?: LlmsConfig
-  analytics?: AnalyticsConfig
-}
+import { z } from 'zod'
 
-export interface LlmsConfig {
-  enabled?: boolean
-}
+const logoSchema = z.object({
+  light: z.string().optional(),
+  dark: z.string().optional(),
+})
 
-export interface AnalyticsConfig {
-  enabled?: boolean
-  googleAnalytics?: GoogleAnalyticsConfig
-}
+const themeSchema = z.object({
+  name: z.enum(['default', 'paper']),
+  colors: z.record(z.string(), z.string()).optional(),
+})
 
-export interface GoogleAnalyticsConfig {
-  measurementId: string
-}
+const navLinkSchema = z.object({
+  label: z.string(),
+  href: z.string(),
+})
 
-export interface ApiConfig {
-  name: string
-  spec: string
-  basePath: string
-  server: ApiServerConfig
-  auth?: ApiAuthConfig
-}
+const socialLinkSchema = z.object({
+  type: z.string(),
+  href: z.string(),
+})
 
-export interface ApiServerConfig {
-  url: string
-  description?: string
-}
+const navigationSchema = z.object({
+  links: z.array(navLinkSchema).optional(),
+  social: z.array(socialLinkSchema).optional(),
+})
 
-export interface ApiAuthConfig {
-  type: string
-  header: string
-  placeholder?: string
-}
+const searchSchema = z.object({
+  enabled: z.boolean().optional(),
+  placeholder: z.string().optional(),
+})
 
-export interface LogoConfig {
-  light?: string
-  dark?: string
-}
+const apiServerSchema = z.object({
+  url: z.string(),
+  description: z.string().optional(),
+})
 
-export interface ThemeConfig {
-  name: 'default' | 'paper'
-  colors?: Record<string, string>
-}
+const apiAuthSchema = z.object({
+  type: z.string(),
+  header: z.string(),
+  placeholder: z.string().optional(),
+})
 
-export interface NavigationConfig {
-  links?: NavLink[]
-  social?: SocialLink[]
-}
+const apiSchema = z.object({
+  name: z.string(),
+  spec: z.string(),
+  basePath: z.string(),
+  server: apiServerSchema,
+  auth: apiAuthSchema.optional(),
+})
 
-export interface NavLink {
-  label: string
-  href: string
-}
+const footerSchema = z.object({
+  copyright: z.string().optional(),
+  links: z.array(navLinkSchema).optional(),
+})
 
-export interface SocialLink {
-  type: 'github' | 'twitter' | 'discord' | string
-  href: string
-}
+const llmsSchema = z.object({
+  enabled: z.boolean().optional(),
+})
 
-export interface SearchConfig {
-  enabled?: boolean
-  placeholder?: string
-}
+const googleAnalyticsSchema = z.object({
+  measurementId: z.string(),
+})
 
-export interface FooterConfig {
-  copyright?: string
-  links?: NavLink[]
-}
+const analyticsSchema = z.object({
+  enabled: z.boolean().optional(),
+  googleAnalytics: googleAnalyticsSchema.optional(),
+})
+
+export const chronicleConfigSchema = z.object({
+  title: z.string(),
+  description: z.string().optional(),
+  url: z.string().optional(),
+  content: z.string().optional(),
+  preset: z.string().optional(),
+  logo: logoSchema.optional(),
+  theme: themeSchema.optional(),
+  navigation: navigationSchema.optional(),
+  search: searchSchema.optional(),
+  footer: footerSchema.optional(),
+  api: z.array(apiSchema).optional(),
+  llms: llmsSchema.optional(),
+  analytics: analyticsSchema.optional(),
+})
+
+export type ChronicleConfig = z.infer<typeof chronicleConfigSchema>
+export type LogoConfig = z.infer<typeof logoSchema>
+export type ThemeConfig = z.infer<typeof themeSchema>
+export type NavigationConfig = z.infer<typeof navigationSchema>
+export type NavLink = z.infer<typeof navLinkSchema>
+export type SocialLink = z.infer<typeof socialLinkSchema>
+export type SearchConfig = z.infer<typeof searchSchema>
+export type ApiConfig = z.infer<typeof apiSchema>
+export type ApiServerConfig = z.infer<typeof apiServerSchema>
+export type ApiAuthConfig = z.infer<typeof apiAuthSchema>
+export type FooterConfig = z.infer<typeof footerSchema>
+export type LlmsConfig = z.infer<typeof llmsSchema>
+export type AnalyticsConfig = z.infer<typeof analyticsSchema>
+export type GoogleAnalyticsConfig = z.infer<typeof googleAnalyticsSchema>

package/src/types/content.ts

@@ -1,4 +1,8 @@
 import type { ReactNode } from 'react'
+import type { TableOfContents } from 'fumadocs-core/toc'
+
+export type { Root, Node, Item, Folder, Separator } from 'fumadocs-core/page-tree'
+export type { TOCItemType, TableOfContents } from 'fumadocs-core/toc'
 
 export interface Frontmatter {
   title: string
@@ -12,25 +16,5 @@ export interface Page {
   slug: string[]
   frontmatter: Frontmatter
   content: ReactNode
-  toc: TocItem[]
-}
-
-export interface TocItem {
-  title: string
-  url: string
-  depth: number
-}
-
-export interface PageTreeItem {
-  type: 'page' | 'folder' | 'separator'
-  name: string
-  url?: string
-  order?: number
-  icon?: string
-  children?: PageTreeItem[]
-}
-
-export interface PageTree {
-  name: string
-  children: PageTreeItem[]
+  toc: TableOfContents
 }

package/src/types/globals.d.ts

@@ -0,0 +1,4 @@
+// Vite build-time constants (injected via define in vite-config.ts)
+declare const __CHRONICLE_CONTENT_DIR__: string
+declare const __CHRONICLE_PROJECT_ROOT__: string
+declare const __CHRONICLE_CONFIG_RAW__: string | null

package/src/types/theme.ts

@@ -1,18 +1,19 @@
 import type { ReactNode } from 'react'
+import type { Root } from 'fumadocs-core/page-tree'
 import type { ChronicleConfig } from './config'
-import type { Page, PageTree } from './content'
+import type { Page } from './content'
 
 export interface ThemeLayoutProps {
   children: ReactNode
   config: ChronicleConfig
-  tree: PageTree
+  tree: Root
   classNames?: { layout?: string; body?: string; sidebar?: string; content?: string }
 }
 
 export interface ThemePageProps {
   page: Page
   config: ChronicleConfig
-  tree: PageTree
+  tree: Root
 }
 
 export interface Theme {

package/tsconfig.json

@@ -21,10 +21,9 @@
     "lib": ["ES2022", "DOM", "DOM.Iterable"],
     "moduleResolution": "bundler",
     "paths": {
-      "@/*": ["./src/*"],
-      "@/.source/*": ["./.source/*"]
+      "@/*": ["./src/*"]
     }
   },
-  "include": ["src", ".source", "source.config.ts"],
+  "include": ["src"],
   "exclude": ["node_modules", "dist"]
 }

package/next.config.mjs

@@ -1,10 +0,0 @@
-import { createMDX } from 'fumadocs-mdx/next'
-
-const withMDX = createMDX()
-
-/** @type {import('next').NextConfig} */
-const nextConfig = {
-  reactStrictMode: true,
-}
-
-export default withMDX(nextConfig)

package/source.config.ts

@@ -1,51 +0,0 @@
-import { defineDocs, defineConfig, frontmatterSchema } from 'fumadocs-mdx/config'
-import { z } from 'zod'
-import remarkDirective from 'remark-directive'
-import { remarkDirectiveAdmonition, remarkMdxMermaid } from 'fumadocs-core/mdx-plugins'
-import remarkUnusedDirectives from './src/lib/remark-unused-directives'
-
-const contentDir = process.env.CHRONICLE_CONTENT_DIR || './content'
-
-export const docs = defineDocs({
-  dir: contentDir,
-  docs: {
-    schema: frontmatterSchema.extend({
-      order: z.number().optional(),
-      lastModified: z.string().optional(),
-    }),
-    postprocess: {
-      includeProcessedMarkdown: true,
-    },
-    files: ['**/*.mdx', '**/*.md', '!**/node_modules/**'],
-  },
-})
-
-export default defineConfig({
-  mdxOptions: {
-    remarkPlugins: [
-      remarkDirective,
-      [
-        remarkDirectiveAdmonition,
-        {
-          tags: {
-            CalloutContainer: 'Callout',
-            CalloutTitle: 'CalloutTitle',
-            CalloutDescription: 'CalloutDescription',
-          },
-          types: {
-            note: 'accent',
-            tip: 'accent',
-            info: 'accent',
-            warn: 'attention',
-            warning: 'attention',
-            danger: 'alert',
-            caution: 'alert',
-            success: 'success',
-          },
-        },
-      ],
-      remarkUnusedDirectives,
-      remarkMdxMermaid,
-    ],
-  },
-})

package/src/app/[[...slug]]/layout.tsx

@@ -1,15 +0,0 @@
-import { loadConfig } from '@/lib/config'
-import { buildPageTree } from '@/lib/source'
-import { getTheme } from '@/themes/registry'
-
-export default function DocsLayout({ children }: { children: React.ReactNode }) {
-  const config = loadConfig()
-  const tree = buildPageTree()
-  const { Layout, className } = getTheme(config.theme?.name)
-
-  return (
-    <Layout config={config} tree={tree} classNames={{ layout: className }}>
-      {children}
-    </Layout>
-  )
-}

package/src/app/[[...slug]]/page.tsx

@@ -1,106 +0,0 @@
-import type { Metadata, ResolvingMetadata } from 'next'
-import { notFound } from 'next/navigation'
-import type { MDXContent } from 'mdx/types'
-import { loadConfig } from '@/lib/config'
-import { source, buildPageTree } from '@/lib/source'
-import { getTheme } from '@/themes/registry'
-import { mdxComponents } from '@/components/mdx'
-
-interface PageProps {
-  params: Promise<{ slug?: string[] }>
-}
-
-interface PageData {
-  title: string
-  description?: string
-  body: MDXContent
-  toc: { title: string; url: string; depth: number }[]
-}
-
-export async function generateMetadata(
-  { params }: PageProps,
-  parent: ResolvingMetadata,
-): Promise<Metadata> {
-  const { slug } = await params
-  const page = source.getPage(slug)
-  if (!page) return {}
-  const config = loadConfig()
-  const data = page.data as PageData
-  const parentMetadata = await parent
-
-  const metadata: Metadata = {
-    title: data.title,
-    description: data.description,
-  }
-
-  if (config.url) {
-    const ogParams = new URLSearchParams({ title: data.title })
-    if (data.description) ogParams.set('description', data.description)
-    metadata.openGraph = {
-      ...parentMetadata.openGraph,
-      title: data.title,
-      description: data.description,
-      images: [{ url: `/og?${ogParams.toString()}`, width: 1200, height: 630 }],
-    }
-    metadata.twitter = {
-      ...parentMetadata.twitter,
-      title: data.title,
-      description: data.description,
-    }
-  }
-
-  return metadata
-}
-
-export default async function DocsPage({ params }: PageProps) {
-  const { slug } = await params
-  const config = loadConfig()
-
-  const page = source.getPage(slug)
-
-  if (!page) {
-    notFound()
-  }
-
-  const { Page } = getTheme(config.theme?.name)
-
-  const data = page.data as PageData
-  const MDXBody = data.body
-
-  const tree = buildPageTree()
-
-  const pageUrl = config.url ? `${config.url}/${(slug ?? []).join('/')}` : undefined
-
-  return (
-    <>
-      <script type="application/ld+json">
-        {JSON.stringify({
-          '@context': 'https://schema.org',
-          '@type': 'Article',
-          headline: data.title,
-          description: data.description,
-          ...(pageUrl && { url: pageUrl }),
-        }, null, 2)}
-      </script>
-      <Page
-        page={{
-          slug: slug ?? [],
-          frontmatter: {
-            title: data.title,
-            description: data.description,
-          },
-          content: <MDXBody components={mdxComponents} />,
-          toc: data.toc ?? [],
-        }}
-        config={config}
-        tree={tree}
-      />
-    </>
-  )
-}
-
-export function generateStaticParams() {
-  return source.getPages().map((page) => ({
-    slug: page.slugs,
-  }))
-}

package/src/app/api/apis-proxy/route.ts

@@ -1,59 +0,0 @@
-import { NextRequest, NextResponse } from "next/server";
-import { loadConfig } from "@/lib/config";
-import { loadApiSpecs } from "@/lib/openapi";
-
-export async function POST(request: NextRequest) {
-  const { specName, method, path, headers, body } = await request.json();
-
-  if (!specName || !method || !path) {
-    return NextResponse.json(
-      { error: "Missing specName, method, or path" },
-      { status: 400 },
-    );
-  }
-
-  const config = loadConfig();
-  const specs = loadApiSpecs(config.api ?? []);
-  const spec = specs.find((s) => s.name === specName);
-
-  if (!spec) {
-    return NextResponse.json(
-      { error: `Unknown spec: ${specName}` },
-      { status: 404 },
-    );
-  }
-
-  const url = spec.server.url + path;
-
-  try {
-    const response = await fetch(url, {
-      method,
-      headers,
-      body: body ? JSON.stringify(body) : undefined,
-    });
-
-    const contentType = response.headers.get("content-type") ?? "";
-    const responseBody = contentType.includes("application/json")
-      ? await response.json()
-      : await response.text();
-
-    return NextResponse.json({
-      status: response.status,
-      statusText: response.statusText,
-      body: responseBody,
-    }, { status: response.status });
-  } catch (error) {
-    const message =
-      error instanceof Error
-        ? `${error.message}${error.cause ? `: ${(error.cause as Error).message}` : ""}`
-        : "Request failed";
-    return NextResponse.json(
-      {
-        status: 502,
-        statusText: "Bad Gateway",
-        body: `Could not reach ${url}\n${message}`,
-      },
-      { status: 502 },
-    );
-  }
-}

package/src/app/api/health/route.ts

@@ -1,3 +0,0 @@
-export function GET() {
-  return Response.json({ status: 'ok' })
-}

package/src/app/api/search/route.ts

@@ -1,90 +0,0 @@
-import { source } from '@/lib/source'
-import { createSearchAPI, type AdvancedIndex } from 'fumadocs-core/search/server'
-import type { StructuredData } from 'fumadocs-core/mdx-plugins'
-import type { OpenAPIV3 } from 'openapi-types'
-import { loadConfig } from '@/lib/config'
-import { loadApiSpecs, type ApiSpec } from '@/lib/openapi'
-import { getSpecSlug } from '@/lib/api-routes'
-
-interface PageData {
-  title?: string
-  description?: string
-  structuredData?: StructuredData
-  load?: () => Promise<{ structuredData?: StructuredData }>
-}
-
-const HTTP_METHODS = ['get', 'post', 'put', 'delete', 'patch'] as const
-type HttpMethod = (typeof HTTP_METHODS)[number]
-
-function getParamNames(op: OpenAPIV3.OperationObject): string[] {
-  const params = (op.parameters as OpenAPIV3.ParameterObject[] | undefined) ?? []
-  return params.map((p) => p.name)
-}
-
-function buildStructuredData(op: OpenAPIV3.OperationObject, method: string, pathStr: string) {
-  return {
-    headings: [{ id: op.operationId!, content: `${method.toUpperCase()} ${pathStr}` }],
-    contents: [{ heading: op.operationId!, content: `${method.toUpperCase()} ${[op.description, ...getParamNames(op)].filter(Boolean).join(' ')}` }],
-  }
-}
-
-function operationToIndex(specSlug: string, pathStr: string, method: HttpMethod, op: OpenAPIV3.OperationObject): AdvancedIndex {
-  const url = `/apis/${specSlug}/${encodeURIComponent(op.operationId!)}`
-  return {
-    id: url,
-    url,
-    title: `${method.toUpperCase()} ${op.summary ?? op.operationId!}`,
-    description: op.description ?? '',
-    structuredData: buildStructuredData(op, method, pathStr),
-  }
-}
-
-function pathEntryToIndexes(specSlug: string) {
-  return ([pathStr, pathItem]: [string, OpenAPIV3.PathItemObject | undefined]): AdvancedIndex[] => {
-    if (!pathItem) return []
-    const hasOp = (m: HttpMethod) => !!pathItem[m]?.operationId
-    const toIndex = (m: HttpMethod) => operationToIndex(specSlug, pathStr, m, pathItem[m]!)
-    return HTTP_METHODS.filter(hasOp).map(toIndex)
-  }
-}
-
-function specToIndexes(spec: ApiSpec): AdvancedIndex[] {
-  const specSlug = getSpecSlug(spec)
-  return Object.entries(spec.document.paths ?? {}).flatMap(pathEntryToIndexes(specSlug))
-}
-
-function buildApiIndexes(): AdvancedIndex[] {
-  const config = loadConfig()
-  if (!config.api?.length) return []
-  return loadApiSpecs(config.api).flatMap(specToIndexes)
-}
-
-export const { GET } = createSearchAPI('advanced', {
-  indexes: async (): Promise<AdvancedIndex[]> => {
-    const pages = source.getPages()
-    const indexes = await Promise.all(
-      pages.map(async (page): Promise<AdvancedIndex> => {
-        const data = page.data as PageData
-        let structuredData: StructuredData | undefined = data.structuredData
-
-        if (!structuredData && data.load) {
-          try {
-            const loaded = await data.load()
-            structuredData = loaded.structuredData
-          } catch (error) {
-            console.error(`Failed to load structured data for ${page.url}:`, error)
-          }
-        }
-
-        return {
-          id: page.url,
-          url: page.url,
-          title: data.title ?? '',
-          description: data.description ?? '',
-          structuredData: structuredData ?? { headings: [], contents: [] },
-        }
-      })
-    )
-    return [...indexes, ...buildApiIndexes()]
-  },
-})

package/src/app/apis/[[...slug]]/layout.tsx

@@ -1,26 +0,0 @@
-import { cx } from 'class-variance-authority'
-import { loadConfig } from '@/lib/config'
-import { loadApiSpecs } from '@/lib/openapi'
-import { buildApiPageTree } from '@/lib/api-routes'
-import { getTheme } from '@/themes/registry'
-import { Search } from '@/components/ui/search'
-import styles from './layout.module.css'
-
-export default function ApiLayout({ children }: { children: React.ReactNode }) {
-  const config = loadConfig()
-  const { Layout, className } = getTheme(config.theme?.name)
-  const specs = loadApiSpecs(config.api ?? [])
-  const tree = buildApiPageTree(specs)
-
-  return (
-    <Layout config={config} tree={tree} classNames={{
-      layout: cx(styles.layout, className),
-      body: styles.body,
-      sidebar: styles.sidebar,
-      content: styles.content,
-    }}>
-      <Search className={styles.hiddenSearch} />
-      {children}
-    </Layout>
-  )
-}