@aravindc26/velu 0.10.0 → 0.11.0

package/src/engine/lib/velu.ts

@@ -1,15 +1,98 @@
 import { readFileSync } from 'node:fs';
 import { resolve } from 'node:path';
+import { normalizeConfigNavigation } from './navigation-normalize';
 
 interface VeluTab {
   tab: string;
+  slug?: string;
   href?: string;
+  pages?: Array<string | VeluSeparator | VeluLink>;
+  groups?: VeluGroup[];
+}
+
+interface VeluSeparator {
+  separator: string;
+}
+
+interface VeluLink {
+  href: string;
+  label: string;
+}
+
+interface VeluGroup {
+  group: string;
+  slug?: string;
+  pages: Array<string | VeluGroup | VeluSeparator | VeluLink>;
+}
+
+interface VeluAnchor {
+  anchor: string;
+  href?: string;
+  icon?: string;
+  color?: {
+    light: string;
+    dark: string;
+  };
+  tabs?: VeluTab[];
+  hidden?: boolean;
+}
+
+interface VeluGlobalTab {
+  tab: string;
+  href: string;
+  icon?: string;
+}
+
+interface VeluLanguageNav {
+  language: string;
+  tabs: VeluTab[];
+}
+
+interface VeluProductNav {
+  product: string;
+  description?: string;
+  icon?: string;
+  hidden?: boolean;
+  href?: string;
+}
+
+interface VeluVersionNav {
+  version: string;
+  default?: boolean;
+  hidden?: boolean;
+  href?: string;
+}
+
+export interface VeluProductOption {
+  product: string;
+  slug: string;
+  description?: string;
+  icon?: string;
+  tabSlugs: string[];
+  defaultPath: string;
+}
+
+export interface VeluVersionOption {
+  version: string;
+  slug: string;
+  isDefault: boolean;
+  tabSlugs: string[];
+  defaultPath: string;
 }
 
 interface VeluConfig {
   appearance?: 'system' | 'light' | 'dark';
+  languages?: string[];
   navigation: {
-    tabs: VeluTab[];
+    tabs?: VeluTab[];
+    languages?: VeluLanguageNav[];
+    products?: VeluProductNav[];
+    versions?: VeluVersionNav[];
+    anchors?: VeluAnchor[];
+    global?: {
+      anchors?: VeluAnchor[];
+      tabs?: VeluGlobalTab[];
+    };
   };
 }
 
@@ -19,20 +102,201 @@ function loadVeluConfig(): VeluConfig {
   if (cachedConfig) return cachedConfig;
   const configPath = resolve(process.cwd(), 'velu.json');
   const raw = readFileSync(configPath, 'utf-8');
-  cachedConfig = JSON.parse(raw) as VeluConfig;
+  cachedConfig = normalizeConfigNavigation(JSON.parse(raw)) as VeluConfig;
   return cachedConfig;
 }
 
+function isGroup(item: unknown): item is VeluGroup {
+  return typeof item === 'object' && item !== null && 'group' in item;
+}
+
+function slugify(input: string, fallback: string): string {
+  const slug = input
+    .toLowerCase()
+    .trim()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '');
+  return slug || fallback;
+}
+
+function pageBasename(page: string): string {
+  const parts = page.split('/').filter(Boolean);
+  return parts[parts.length - 1] ?? page;
+}
+
+function findFirstPageInGroup(group: VeluGroup): string | undefined {
+  for (const item of group.pages) {
+    if (typeof item === 'string') return item;
+    if (isGroup(item)) {
+      const nested = findFirstPageInGroup(item);
+      if (nested) return nested;
+    }
+  }
+  return undefined;
+}
+
+function findFirstPageInTab(tab: VeluTab): string | undefined {
+  if (tab.pages) {
+    for (const item of tab.pages) {
+      if (typeof item === 'string') return item;
+    }
+  }
+  if (tab.groups) {
+    for (const group of tab.groups) {
+      const nested = findFirstPageInGroup(group);
+      if (nested) return nested;
+    }
+  }
+  return undefined;
+}
+
+function parseVersionParts(version: string): number[] {
+  const parts = version.match(/\d+/g);
+  return parts ? parts.map((n) => Number(n)) : [];
+}
+
+function compareVersionParts(a: number[], b: number[]): number {
+  const len = Math.max(a.length, b.length);
+  for (let i = 0; i < len; i += 1) {
+    const av = a[i] ?? 0;
+    const bv = b[i] ?? 0;
+    if (av !== bv) return av - bv;
+  }
+  return 0;
+}
+
 export function getExternalTabs(): Array<{ label: string; href: string }> {
   const config = loadVeluConfig();
   const tabs = config.navigation?.tabs ?? [];
+  const globalTabs = config.navigation?.global?.tabs ?? [];
 
-  return tabs
+  const tabLinks = tabs
     .filter((tab): tab is VeluTab & { href: string } => typeof tab.href === 'string' && tab.href.length > 0)
     .map((tab) => ({
       label: tab.tab,
       href: tab.href,
     }));
+
+  const globalLinks = globalTabs
+    .filter((tab): tab is VeluGlobalTab => typeof tab.href === 'string' && tab.href.length > 0)
+    .map((tab) => ({
+      label: tab.tab,
+      href: tab.href,
+    }));
+
+  return [...tabLinks, ...globalLinks];
+}
+
+export function getNavbarAnchors(): VeluAnchor[] {
+  const config = loadVeluConfig();
+  return (config.navigation.anchors ?? []).filter(
+    (a): a is VeluAnchor & { href: string } => typeof a.href === 'string' && a.href.length > 0 && !a.hidden
+  );
+}
+
+export function getGlobalAnchors(): VeluAnchor[] {
+  const config = loadVeluConfig();
+  return (config.navigation.global?.anchors ?? []).filter(
+    (a): a is VeluAnchor & { href: string } => typeof a.href === 'string' && a.href.length > 0 && !a.hidden
+  );
+}
+
+export function getLanguages(): string[] {
+  const config = loadVeluConfig();
+  // Prefer navigation.languages codes, fall back to top-level languages
+  if (config.navigation.languages && config.navigation.languages.length > 0) {
+    return config.navigation.languages.map((l) => l.language);
+  }
+  return config.languages ?? [];
+}
+
+export function getProductOptions(): VeluProductOption[] {
+  const config = loadVeluConfig();
+  const products = (config.navigation.products ?? []).filter((p) => !p.hidden);
+  if (products.length === 0) return [];
+
+  const allTabs = config.navigation.tabs ?? [];
+
+  return products.map((product, index) => {
+    const prefix = slugify(product.product, `product-${index + 1}`);
+    const productTabs = allTabs.filter((tab) => {
+      const slug = tab.slug ?? '';
+      return slug === prefix || slug.startsWith(`${prefix}/`);
+    });
+
+    const tabSlugs = productTabs
+      .map((tab) => tab.slug)
+      .filter((slug): slug is string => typeof slug === 'string' && slug.length > 0);
+
+    const firstTab = productTabs[0];
+    const firstPage = firstTab ? findFirstPageInTab(firstTab) : undefined;
+    const defaultPath = firstTab
+      ? (firstPage ? `/${firstTab.slug}/${pageBasename(firstPage)}` : `/${firstTab.slug}`)
+      : (product.href ?? '/');
+
+    return {
+      product: product.product,
+      slug: prefix,
+      description: product.description,
+      icon: product.icon,
+      tabSlugs,
+      defaultPath,
+    };
+  });
+}
+
+export function getVersionOptions(): VeluVersionOption[] {
+  const config = loadVeluConfig();
+  const versions = (config.navigation.versions ?? []).filter((v) => !v.hidden);
+  if (versions.length === 0) return [];
+
+  const allTabs = config.navigation.tabs ?? [];
+
+  const baseEntries = versions.map((version, index) => {
+    const prefix = slugify(version.version, `version-${index + 1}`);
+    const versionTabs = allTabs.filter((tab) => {
+      const slug = tab.slug ?? '';
+      return slug === prefix || slug.startsWith(`${prefix}/`);
+    });
+
+    const tabSlugs = versionTabs
+      .map((tab) => tab.slug)
+      .filter((slug): slug is string => typeof slug === 'string' && slug.length > 0);
+
+    const firstTab = versionTabs[0];
+    const firstPage = firstTab ? findFirstPageInTab(firstTab) : undefined;
+    const defaultPath = firstTab
+      ? (firstPage ? `/${firstTab.slug}/${pageBasename(firstPage)}` : `/${firstTab.slug}`)
+      : (version.href ?? '/');
+
+    return {
+      version: version.version,
+      slug: prefix,
+      explicitDefault: version.default === true,
+      versionParts: parseVersionParts(version.version),
+      tabSlugs,
+      defaultPath,
+      order: index,
+    };
+  });
+
+  const explicitDefault = baseEntries.find((entry) => entry.explicitDefault);
+  const latest = explicitDefault
+    ?? baseEntries
+      .slice()
+      .sort((a, b) => {
+        const cmp = compareVersionParts(b.versionParts, a.versionParts);
+        if (cmp !== 0) return cmp;
+        return a.order - b.order;
+      })[0];
+
+  return baseEntries.map((entry) => ({
+    version: entry.version,
+    slug: entry.slug,
+    isDefault: entry.slug === latest?.slug,
+    tabSlugs: entry.tabSlugs,
+    defaultPath: entry.defaultPath,
+  }));
 }
 
 export function getAppearance(): 'system' | 'light' | 'dark' {

package/src/engine/next.config.mjs

@@ -7,8 +7,8 @@ const withMDX = createMDX({
 
 /** @type {import('next').NextConfig} */
 const config = {
-  reactStrictMode: true,
-  output: 'export',
+  reactStrictMode: false,
+  output: process.env.NODE_ENV === 'production' ? 'export' : undefined,
   distDir: 'dist',
   devIndicators: false,
   turbopack: {

package/src/engine/src/lib/velu.ts

@@ -1,15 +1,46 @@
 import { readFileSync } from 'node:fs';
 import { resolve } from 'node:path';
+import { normalizeConfigNavigation } from '../../lib/navigation-normalize';
 
 // ── Types ───────────────────────────────────────────────────────────────────
 
+export interface VeluSeparator {
+  separator: string;
+}
+
+export interface VeluLink {
+  href: string;
+  label: string;
+  icon?: string;
+}
+
+export interface VeluAnchor {
+  anchor: string;
+  href?: string;
+  icon?: string;
+  color?: {
+    light: string;
+    dark: string;
+  };
+  tabs?: VeluTab[];
+  hidden?: boolean;
+}
+
+export interface VeluGlobalTab {
+  tab: string;
+  href: string;
+  icon?: string;
+}
+
 export interface VeluGroup {
   group: string;
   slug: string;
   icon?: string;
   tag?: string;
   expanded?: boolean;
-  pages: (string | VeluGroup)[];
+  description?: string;
+  hidden?: boolean;
+  pages: (string | VeluGroup | VeluSeparator | VeluLink)[];
 }
 
 export interface VeluTab {
@@ -17,7 +48,7 @@ export interface VeluTab {
   slug: string;
   icon?: string;
   href?: string;
-  pages?: string[];
+  pages?: (string | VeluSeparator | VeluLink)[];
   groups?: VeluGroup[];
 }
 
@@ -28,7 +59,12 @@ export interface VeluConfig {
   appearance?: 'system' | 'light' | 'dark';
   styling?: { codeblocks?: { theme?: string | { light: string; dark: string } } };
   navigation: {
-    tabs: VeluTab[];
+    tabs?: VeluTab[];
+    anchors?: VeluAnchor[];
+    global?: {
+      anchors?: VeluAnchor[];
+      tabs?: VeluGlobalTab[];
+    };
   };
 }
 
@@ -48,7 +84,7 @@ export function loadVeluConfig(): VeluConfig {
   if (_cachedConfig) return _cachedConfig;
   const configPath = resolve(process.cwd(), 'velu.json');
   const raw = readFileSync(configPath, 'utf-8');
-  _cachedConfig = JSON.parse(raw);
+  _cachedConfig = normalizeConfigNavigation(JSON.parse(raw));
   return _cachedConfig!;
 }
 
@@ -64,7 +100,7 @@ function veluGroupToSidebar(group: VeluGroup, tabSlug: string): any {
   for (const item of group.pages) {
     if (typeof item === 'string') {
       items.push(tabSlug + '/' + group.slug + '/' + pageBasename(item));
-    } else {
+    } else if (isGroup(item)) {
       items.push(veluGroupToSidebar(item, tabSlug));
     }
   }
@@ -74,10 +110,18 @@ function veluGroupToSidebar(group: VeluGroup, tabSlug: string): any {
   return result;
 }
 
+function isGroup(item: unknown): item is VeluGroup {
+  return typeof item === 'object' && item !== null && 'group' in item;
+}
+
 /** Get the first page dest path for a tab */
 function firstTabPage(tab: VeluTab): string | undefined {
-  if (tab.pages && tab.pages.length > 0) {
-    return tab.slug + '/' + pageBasename(tab.pages[0]);
+  if (tab.pages) {
+    for (const item of tab.pages) {
+      if (typeof item === 'string') {
+        return tab.slug + '/' + pageBasename(item);
+      }
+    }
   }
   if (tab.groups) {
     for (const g of tab.groups) {
@@ -91,8 +135,10 @@ function firstTabPage(tab: VeluTab): string | undefined {
 function firstGroupPage(group: VeluGroup, tabSlug: string): string | undefined {
   for (const item of group.pages) {
     if (typeof item === 'string') return tabSlug + '/' + group.slug + '/' + pageBasename(item);
-    const nested = firstGroupPage(item, tabSlug);
-    if (nested) return nested;
+    if (isGroup(item)) {
+      const nested = firstGroupPage(item, tabSlug);
+      if (nested) return nested;
+    }
   }
   return undefined;
 }
@@ -104,12 +150,14 @@ export function getSidebar(): any[] {
   const config = loadVeluConfig();
   const sidebar: any[] = [];
 
-  for (const tab of config.navigation.tabs) {
+  for (const tab of config.navigation.tabs ?? []) {
     if (tab.href) continue;
     const items: any[] = [];
     if (tab.groups) for (const g of tab.groups) items.push(veluGroupToSidebar(g, tab.slug));
     if (tab.pages) {
-      for (const p of tab.pages) items.push(tab.slug + '/' + pageBasename(p));
+      for (const p of tab.pages) {
+        if (typeof p === 'string') items.push(tab.slug + '/' + pageBasename(p));
+      }
     }
     sidebar.push({ label: tab.tab, items });
   }
@@ -122,7 +170,7 @@ export function getTabs(): TabMeta[] {
   const config = loadVeluConfig();
   const tabs: TabMeta[] = [];
 
-  for (const tab of config.navigation.tabs) {
+  for (const tab of config.navigation.tabs ?? []) {
     if (tab.href) {
       tabs.push({ label: tab.tab, icon: tab.icon, href: tab.href, slugs: [] });
     } else {
@@ -144,10 +192,35 @@ export function getTabSidebarMap(): Record<string, string[]> {
   const config = loadVeluConfig();
   const map: Record<string, string[]> = {};
 
-  for (const tab of config.navigation.tabs) {
+  for (const tab of config.navigation.tabs ?? []) {
     if (tab.href) continue;
     map[tab.slug] = [tab.tab];
   }
 
   return map;
 }
+
+/** Get all anchors (navigation.anchors + navigation.global.anchors), excluding hidden ones */
+export function getAnchors(): VeluAnchor[] {
+  const config = loadVeluConfig();
+  const anchors: VeluAnchor[] = [];
+  if (config.navigation.anchors) {
+    anchors.push(...config.navigation.anchors.filter((a) => typeof a.href === 'string' && a.href.length > 0 && !a.hidden));
+  }
+  if (config.navigation.global?.anchors) {
+    anchors.push(...config.navigation.global.anchors.filter((a) => typeof a.href === 'string' && a.href.length > 0 && !a.hidden));
+  }
+  return anchors;
+}
+
+/** Get external tab links for the navbar */
+export function getExternalTabs(): { label: string; href: string; icon?: string }[] {
+  const config = loadVeluConfig();
+  const tabLinks = (config.navigation.tabs ?? [])
+    .filter((tab) => !!tab.href)
+    .map((tab) => ({ label: tab.tab, href: tab.href!, icon: tab.icon }));
+  const globalLinks = (config.navigation.global?.tabs ?? [])
+    .filter((tab) => !!tab.href)
+    .map((tab) => ({ label: tab.tab, href: tab.href, icon: tab.icon }));
+  return [...tabLinks, ...globalLinks];
+}