@aravindc26/velu 0.10.0 → 0.11.1

package/src/themes.ts

@@ -129,11 +129,11 @@ function generateThemeCss(config: ThemeConfig): string {
     if (lightAccent) {
       const palette = deriveAccentPalette(lightAccent);
       lines.push(":root {");
-      lines.push(`  --color-fd-primary: ${palette.light.accent};`);
-      lines.push(`  --color-fd-primary-foreground: ${textColorFor(palette.light.accent)};`);
+      lines.push(`  --color-fd-primary: ${lightAccent};`);
+      lines.push(`  --color-fd-primary-foreground: ${textColorFor(lightAccent)};`);
       lines.push(`  --color-fd-accent: ${palette.light.accentLow};`);
       lines.push(`  --color-fd-accent-foreground: ${textColorFor(palette.light.accentLow)};`);
-      lines.push(`  --color-fd-ring: ${palette.light.accent};`);
+      lines.push(`  --color-fd-ring: ${lightAccent};`);
       lines.push("}");
       lines.push("");
     }
@@ -141,11 +141,11 @@ function generateThemeCss(config: ThemeConfig): string {
     if (darkAccent) {
       const palette = deriveAccentPalette(darkAccent);
       lines.push(".dark {");
-      lines.push(`  --color-fd-primary: ${palette.dark.accent};`);
-      lines.push(`  --color-fd-primary-foreground: ${textColorFor(palette.dark.accent)};`);
+      lines.push(`  --color-fd-primary: ${darkAccent};`);
+      lines.push(`  --color-fd-primary-foreground: ${textColorFor(darkAccent)};`);
       lines.push(`  --color-fd-accent: ${palette.dark.accentLow};`);
       lines.push(`  --color-fd-accent-foreground: ${textColorFor(palette.dark.accentLow)};`);
-      lines.push(`  --color-fd-ring: ${palette.dark.accent};`);
+      lines.push(`  --color-fd-ring: ${darkAccent};`);
       lines.push("}");
       lines.push("");
     }

package/src/validate.ts

@@ -2,57 +2,240 @@ import Ajv, { type AnySchema } from "ajv";
 import addFormats from "ajv-formats";
 import { readFileSync, existsSync } from "node:fs";
 import { resolve, join } from "node:path";
+import { normalizeConfigNavigation } from "./navigation-normalize.js";
+const PRIMARY_CONFIG_NAME = "docs.json";
+const LEGACY_CONFIG_NAME = "velu.json";
+
+function resolveConfigPath(docsDir: string): string | null {
+  const primary = join(docsDir, PRIMARY_CONFIG_NAME);
+  if (existsSync(primary)) return primary;
+  const legacy = join(docsDir, LEGACY_CONFIG_NAME);
+  if (existsSync(legacy)) return legacy;
+  return null;
+}
+
+interface VeluSeparator {
+  separator: string;
+}
+
+interface VeluLink {
+  href: string;
+  label: string;
+  icon?: string;
+  iconType?: string;
+}
+
+interface VeluAnchor {
+  anchor: string;
+  href?: string;
+  icon?: string;
+  iconType?: string;
+  version?: string;
+  openapi?: VeluOpenApiSource;
+  asyncapi?: VeluOpenApiSource;
+  color?: {
+    light: string;
+    dark: string;
+  };
+  tabs?: VeluTab[];
+  hidden?: boolean;
+}
+
+interface VeluGlobalTab {
+  tab: string;
+  href: string;
+  icon?: string;
+  iconType?: string;
+}
 
 interface VeluGroup {
   group: string;
-  slug: string;
+  slug?: string;
   icon?: string;
+  iconType?: string;
   tag?: string;
+  version?: string;
+  openapi?: VeluOpenApiSource;
+  asyncapi?: VeluOpenApiSource;
   expanded?: boolean;
-  pages: (string | VeluGroup)[];
+  description?: string;
+  hidden?: boolean;
+  pages: (string | VeluGroup | VeluSeparator | VeluLink)[];
+}
+
+interface VeluMenuItem {
+  item: string;
+  icon?: string;
+  iconType?: string;
+  openapi?: VeluOpenApiSource;
+  asyncapi?: VeluOpenApiSource;
+  groups?: VeluGroup[];
+  pages?: (string | VeluSeparator | VeluLink)[];
 }
 
 interface VeluTab {
   tab: string;
-  slug: string;
+  slug?: string;
   icon?: string;
+  iconType?: string;
+  version?: string;
   href?: string;
-  pages?: string[];
+  openapi?: VeluOpenApiSource;
+  asyncapi?: VeluOpenApiSource;
+  pages?: (string | VeluSeparator | VeluLink)[];
   groups?: VeluGroup[];
+  menu?: VeluMenuItem[];
+}
+
+interface VeluLanguageNav {
+  language: string;
+  openapi?: VeluOpenApiSource;
+  asyncapi?: VeluOpenApiSource;
+  tabs: VeluTab[];
+}
+
+interface VeluProductNav {
+  product: string;
+  icon?: string;
+  iconType?: string;
+  openapi?: VeluOpenApiSource;
+  asyncapi?: VeluOpenApiSource;
+  tabs?: VeluTab[];
+  pages?: (string | VeluSeparator | VeluLink)[];
 }
 
+interface VeluVersionNav {
+  version: string;
+  openapi?: VeluOpenApiSource;
+  asyncapi?: VeluOpenApiSource;
+  tabs: VeluTab[];
+}
+
+type VeluOpenApiSource = string | string[] | Record<string, unknown>;
+
 interface VeluConfig {
   $schema?: string;
+  icons?: {
+    library?: "fontawesome" | "lucide" | "tabler";
+  };
   theme?: string;
   colors?: { primary?: string; light?: string; dark?: string };
   appearance?: "system" | "light" | "dark";
   styling?: { codeblocks?: { theme?: string | { light: string; dark: string } } };
+  openapi?: VeluOpenApiSource;
+  asyncapi?: VeluOpenApiSource;
+  api?: {
+    baseUrl?: string;
+    playground?: {
+      mode?: string;
+      display?: string;
+      proxy?: boolean;
+    };
+    examples?: {
+      languages?: string[];
+      defaults?: "required" | "all";
+      prefill?: boolean;
+      autogenerate?: boolean;
+    };
+    mdx?: {
+      server?: string;
+      auth?: {
+        method?: "bearer" | "basic" | "key" | "none";
+        name?: string;
+      };
+    };
+  };
   navigation: {
-    tabs: VeluTab[];
+    openapi?: VeluOpenApiSource;
+    asyncapi?: VeluOpenApiSource;
+    tabs?: VeluTab[];
+    languages?: VeluLanguageNav[];
+    products?: VeluProductNav[];
+    versions?: VeluVersionNav[];
+    anchors?: VeluAnchor[];
+    global?: {
+      anchors?: VeluAnchor[];
+      tabs?: VeluGlobalTab[];
+    };
   };
 }
 
+const HTTP_METHODS = new Set([
+  "GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS", "HEAD", "TRACE", "CONNECT", "WEBHOOK",
+]);
+
+function isOpenApiOperationReference(value: string): boolean {
+  const trimmed = value.trim();
+  if (!trimmed) return false;
+  const withSpec = trimmed.match(/^(\S+)\s+([A-Za-z]+)\s+(.+)$/);
+  if (withSpec) {
+    const method = withSpec[2].toUpperCase();
+    const endpoint = withSpec[3].trim();
+    if (!HTTP_METHODS.has(method)) return false;
+    if (method === "WEBHOOK") return endpoint.length > 0;
+    return endpoint.startsWith("/");
+  }
+  const noSpec = trimmed.match(/^([A-Za-z]+)\s+(.+)$/);
+  if (!noSpec) return false;
+  const method = noSpec[1].toUpperCase();
+  const endpoint = noSpec[2].trim();
+  if (!HTTP_METHODS.has(method)) return false;
+  if (method === "WEBHOOK") return endpoint.length > 0;
+  return endpoint.startsWith("/");
+}
+
+function isAsyncApiChannelReference(value: string): boolean {
+  const trimmed = value.trim();
+  if (!trimmed) return false;
+  const withSpec = trimmed.match(/^(\S+)\s+(.+)$/);
+  if (!withSpec) return false;
+  const first = withSpec[1].trim();
+  const maybeMethod = first.toUpperCase();
+  if (HTTP_METHODS.has(maybeMethod)) return false;
+  const looksLikeSpec =
+    first.startsWith('/') ||
+    first.startsWith('./') ||
+    first.startsWith('../') ||
+    /^https?:\/\//i.test(first) ||
+    first.endsWith('.json') ||
+    first.endsWith('.yaml') ||
+    first.endsWith('.yml');
+  return looksLikeSpec && withSpec[2].trim().length > 0;
+}
+
 function loadJson(filePath: string): unknown {
   const raw = readFileSync(filePath, "utf-8");
   return JSON.parse(raw);
 }
 
-function collectPages(config: VeluConfig): string[] {
+function isGroup(item: unknown): item is VeluGroup {
+  return typeof item === "object" && item !== null && "group" in item;
+}
+
+function isPageString(item: unknown): item is string {
+  return typeof item === "string";
+}
+
+function collectPagesFromTabs(tabs: VeluTab[]): string[] {
   const pages: string[] = [];
 
   function collectFromGroup(group: VeluGroup) {
     for (const item of group.pages) {
-      if (typeof item === "string") {
+      if (isPageString(item)) {
         pages.push(item);
-      } else {
+      } else if (isGroup(item)) {
         collectFromGroup(item);
       }
     }
   }
 
-  for (const tab of config.navigation.tabs) {
+  for (const tab of tabs) {
     if (tab.pages) {
-      pages.push(...tab.pages);
+      for (const item of tab.pages) {
+        if (isPageString(item)) {
+          pages.push(item);
+        }
+      }
     }
     if (tab.groups) {
       for (const group of tab.groups) {
@@ -64,12 +247,22 @@ function collectPages(config: VeluConfig): string[] {
   return pages;
 }
 
+function collectPages(config: VeluConfig): string[] {
+  const tabs = config.navigation.languages && config.navigation.languages.length > 0
+    ? config.navigation.languages.flatMap((lang) => lang.tabs)
+    : (config.navigation.tabs ?? []);
+  return collectPagesFromTabs(tabs);
+}
+
 function validateVeluConfig(docsDir: string, schemaPath: string): { valid: boolean; errors: string[] } {
   const errors: string[] = [];
 
-  const configPath = join(docsDir, "velu.json");
-  if (!existsSync(configPath)) {
-    return { valid: false, errors: [`velu.json not found at ${configPath}`] };
+  const configPath = resolveConfigPath(docsDir);
+  if (!configPath) {
+    return {
+      valid: false,
+      errors: [`docs.json or velu.json not found at ${join(docsDir, PRIMARY_CONFIG_NAME)}`],
+    };
   }
 
   if (!existsSync(schemaPath)) {
@@ -77,13 +270,13 @@ function validateVeluConfig(docsDir: string, schemaPath: string): { valid: boole
   }
 
   const schema = loadJson(schemaPath) as AnySchema;
-  const config = loadJson(configPath) as VeluConfig;
+  const rawConfig = loadJson(configPath) as VeluConfig;
 
   // Validate against JSON schema
   const ajv = new Ajv({ allErrors: true, strict: false });
   addFormats(ajv);
   const validate = ajv.compile(schema);
-  const schemaValid = validate(config);
+  const schemaValid = validate(rawConfig);
 
   if (!schemaValid && validate.errors) {
     for (const err of validate.errors) {
@@ -91,25 +284,43 @@ function validateVeluConfig(docsDir: string, schemaPath: string): { valid: boole
     }
   }
 
-  // Validate that all referenced .md files exist
+  const config = normalizeConfigNavigation(rawConfig);
+
+  // Validate that all referenced page files exist (.mdx or .md)
   const pages = collectPages(config);
   for (const page of pages) {
+    if (isOpenApiOperationReference(page)) continue;
+    if (isAsyncApiChannelReference(page)) continue;
+    const mdxPath = join(docsDir, `${page}.mdx`);
     const mdPath = join(docsDir, `${page}.md`);
-    if (!existsSync(mdPath)) {
-      errors.push(`Missing page: ${page}.md (expected at ${mdPath})`);
+    if (!existsSync(mdxPath) && !existsSync(mdPath)) {
+      errors.push(`Missing page: ${page}.md or ${page}.mdx (expected at ${mdPath})`);
     }
   }
 
   // Check for duplicate page references
-  const seen = new Set<string>();
-  for (const page of pages) {
-    if (seen.has(page)) {
-      errors.push(`Duplicate page reference: ${page}`);
+  if (config.navigation.languages && config.navigation.languages.length > 0) {
+    for (const lang of config.navigation.languages) {
+      const seen = new Set<string>();
+      const langPages = collectPagesFromTabs(lang.tabs);
+      for (const page of langPages) {
+        if (seen.has(page)) {
+          errors.push(`Duplicate page reference in language '${lang.language}': ${page}`);
+        }
+        seen.add(page);
+      }
+    }
+  } else {
+    const seen = new Set<string>();
+    for (const page of pages) {
+      if (seen.has(page)) {
+        errors.push(`Duplicate page reference: ${page}`);
+      }
+      seen.add(page);
     }
-    seen.add(page);
   }
 
   return { valid: errors.length === 0, errors };
 }
 
-export { validateVeluConfig, collectPages, VeluConfig, VeluGroup, VeluTab };
+export { validateVeluConfig, collectPages, VeluConfig, VeluGroup, VeluTab, VeluSeparator, VeluLink, VeluAnchor };

package/src/engine/app/(docs)/[[...slug]]/page.tsx

@@ -1,69 +0,0 @@
-import type { Metadata } from 'next';
-import { notFound } from 'next/navigation';
-import { createRelativeLink } from 'fumadocs-ui/mdx';
-import {
-  DocsBody,
-  DocsDescription,
-  DocsPage,
-  DocsTitle,
-} from 'fumadocs-ui/layouts/docs/page';
-import { getMDXComponents } from '@/mdx-components';
-import { source } from '@/lib/source';
-import { CopyPageButton } from '@/components/copy-page';
-
-interface RouteParams {
-  slug?: string[];
-}
-
-interface PageProps {
-  params: Promise<RouteParams>;
-}
-
-export default async function Page({ params }: PageProps) {
-  const resolvedParams = await params;
-  const page = source.getPage(resolvedParams.slug);
-
-  if (!page) notFound();
-
-  const MDX = page.data.body;
-
-  return (
-    <DocsPage toc={page.data.toc} full={page.data.full}>
-      <div data-pagefind-body data-pagefind-meta={`title:${page.data.title}`}>
-        <div className="velu-title-row">
-          <DocsTitle>{page.data.title}</DocsTitle>
-          <CopyPageButton />
-        </div>
-        {page.data.description ? <DocsDescription>{page.data.description}</DocsDescription> : null}
-        <DocsBody>
-          <MDX
-            components={getMDXComponents({
-              a: createRelativeLink(source, page),
-            })}
-          />
-        </DocsBody>
-      </div>
-      <footer className="velu-footer">
-        Powered by <a href="https://getvelu.com" target="_blank" rel="noopener noreferrer">Velu</a>
-      </footer>
-    </DocsPage>
-  );
-}
-
-export async function generateStaticParams() {
-  const params = source.generateParams();
-  // Include root path for the optional catch-all [[...slug]]
-  return [{ slug: [] }, ...params];
-}
-
-export async function generateMetadata({ params }: PageProps): Promise<Metadata> {
-  const resolvedParams = await params;
-  const page = source.getPage(resolvedParams.slug);
-
-  if (!page) notFound();
-
-  return {
-    title: page.data.title,
-    description: page.data.description,
-  };
-}