@aravindc26/velu 0.11.0 → 0.11.3

package/src/engine/lib/redirects.ts

@@ -0,0 +1,194 @@
+export interface RedirectRule {
+  source: string;
+  destination: string;
+  permanent?: boolean;
+}
+
+interface RedirectCaptureDescriptor {
+  kind: "named" | "star";
+  key: string;
+}
+
+interface CompiledRedirectRule {
+  source: string;
+  destination: string;
+  permanent: boolean;
+  matcher: RegExp;
+  captures: RedirectCaptureDescriptor[];
+}
+
+const INVALID_PATH_PARTS = /[?#]/;
+const EXTERNAL_PROTOCOL = /^[a-zA-Z][a-zA-Z\d+.-]*:/;
+const NAMED_WILDCARD = /^:([A-Za-z_][A-Za-z0-9_-]*)\*$/;
+const NAMED_SEGMENT = /^:([A-Za-z_][A-Za-z0-9_-]*)$/;
+
+function isObject(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null;
+}
+
+function escapeRegExp(input: string): string {
+  return input.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+export function isExternalDestination(value: string): boolean {
+  return EXTERNAL_PROTOCOL.test(value);
+}
+
+function normalizePath(input: string): string {
+  const trimmed = input.trim();
+  if (trimmed.length === 0) return "/";
+
+  const withLeadingSlash = trimmed.startsWith("/") ? trimmed : `/${trimmed}`;
+  const collapsed = withLeadingSlash.replace(/\/{2,}/g, "/");
+  if (collapsed !== "/" && collapsed.endsWith("/")) {
+    return collapsed.slice(0, -1);
+  }
+  return collapsed;
+}
+
+function compileSourcePattern(source: string): { matcher: RegExp; captures: RedirectCaptureDescriptor[] } {
+  const normalized = normalizePath(source);
+  if (normalized === "/") {
+    return { matcher: /^\/$/, captures: [] };
+  }
+
+  const captures: RedirectCaptureDescriptor[] = [];
+  let starIndex = 0;
+  const segments = normalized.slice(1).split("/");
+  let pattern = "^";
+
+  for (let i = 0; i < segments.length; i += 1) {
+    const segment = segments[i];
+    pattern += "/";
+
+    const namedWildcard = segment.match(NAMED_WILDCARD);
+    if (namedWildcard) {
+      captures.push({ kind: "named", key: namedWildcard[1] });
+      pattern += "(.*)";
+      continue;
+    }
+
+    const namedSegment = segment.match(NAMED_SEGMENT);
+    if (namedSegment) {
+      captures.push({ kind: "named", key: namedSegment[1] });
+      pattern += "([^/]+)";
+      continue;
+    }
+
+    if (!segment.includes("*")) {
+      pattern += escapeRegExp(segment);
+      continue;
+    }
+
+    let segmentPattern = "";
+    for (const char of segment) {
+      if (char === "*") {
+        const key = String(starIndex);
+        starIndex += 1;
+        captures.push({ kind: "star", key });
+        segmentPattern += "([^/]*)";
+      } else {
+        segmentPattern += escapeRegExp(char);
+      }
+    }
+    pattern += segmentPattern;
+  }
+
+  pattern += "/?$";
+  return { matcher: new RegExp(pattern), captures };
+}
+
+function substituteDestination(
+  destination: string,
+  captures: RedirectCaptureDescriptor[],
+  values: string[]
+): string {
+  const named = new Map<string, string>();
+  const stars: string[] = [];
+
+  for (let i = 0; i < captures.length; i += 1) {
+    const capture = captures[i];
+    const value = values[i] ?? "";
+    if (capture.kind === "named") {
+      named.set(capture.key, value);
+    } else {
+      stars.push(value);
+    }
+  }
+
+  let resolved = destination;
+  resolved = resolved.replace(/:([A-Za-z_][A-Za-z0-9_-]*)\*/g, (_, key: string) => named.get(key) ?? "");
+  resolved = resolved.replace(/:([A-Za-z_][A-Za-z0-9_-]*)/g, (_, key: string) => named.get(key) ?? "");
+
+  let starIndex = 0;
+  resolved = resolved.replace(/\*/g, () => stars[starIndex++] ?? "");
+
+  if (isExternalDestination(resolved)) return resolved;
+  return normalizePath(resolved);
+}
+
+export function normalizeRedirectRules(value: unknown): RedirectRule[] {
+  if (!Array.isArray(value)) return [];
+
+  const redirects: RedirectRule[] = [];
+  for (const entry of value) {
+    if (!isObject(entry)) continue;
+    if (typeof entry.source !== "string" || typeof entry.destination !== "string") continue;
+
+    const source = entry.source.trim();
+    const destination = entry.destination.trim();
+    if (source.length === 0 || destination.length === 0) continue;
+    if (INVALID_PATH_PARTS.test(source) || INVALID_PATH_PARTS.test(destination)) continue;
+
+    const normalizedSource = normalizePath(source);
+    const normalizedDestination = isExternalDestination(destination)
+      ? destination
+      : normalizePath(destination);
+    const permanent = entry.permanent === false ? false : true;
+
+    if (!isExternalDestination(normalizedDestination) && normalizedSource === normalizedDestination) continue;
+    redirects.push({
+      source: normalizedSource,
+      destination: normalizedDestination,
+      permanent,
+    });
+  }
+
+  return redirects;
+}
+
+export function compileRedirectRules(rules: RedirectRule[]): CompiledRedirectRule[] {
+  return rules.map((rule) => {
+    const compiled = compileSourcePattern(rule.source);
+    return {
+      source: rule.source,
+      destination: rule.destination,
+      permanent: rule.permanent !== false,
+      matcher: compiled.matcher,
+      captures: compiled.captures,
+    };
+  });
+}
+
+export function resolveRedirect(
+  pathname: string,
+  compiledRules: CompiledRedirectRule[]
+): { destination: string; statusCode: 307 | 308 } | null {
+  const normalizedPath = normalizePath(pathname);
+
+  for (const rule of compiledRules) {
+    const match = normalizedPath.match(rule.matcher);
+    if (!match) continue;
+
+    const values = match.slice(1);
+    const destination = substituteDestination(rule.destination, rule.captures, values);
+
+    if (!isExternalDestination(destination) && destination === normalizedPath) continue;
+    return {
+      destination,
+      statusCode: rule.permanent ? 308 : 307,
+    };
+  }
+
+  return null;
+}

package/src/engine/lib/source.ts

@@ -1,15 +1,118 @@
 import { loader } from 'fumadocs-core/source';
-import { lucideIconsPlugin } from 'fumadocs-core/source/lucide-icons';
-import { docs } from 'fumadocs-mdx:collections/server';
+import { statusBadgesPlugin } from 'fumadocs-core/source/status-badges';
+import * as mdxCollections from 'fumadocs-mdx:collections/server';
+import { createElement } from 'react';
 import { getLanguages } from '@/lib/velu';
 
 const languages = getLanguages();
 const defaultLanguage = languages[0] ?? 'en';
+const OPENAPI_METHODS = new Set(['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'OPTIONS', 'HEAD', 'TRACE', 'WEBHOOK']);
+const docsCollection = (mdxCollections as { docs?: { toFumadocsSource?: () => unknown } }).docs;
+
+if (!docsCollection?.toFumadocsSource) {
+  throw new Error('MDX collections are not ready yet. Please retry in a moment.');
+}
+
+function methodBadgeClass(method: string): string {
+  const upper = method.toUpperCase();
+  if (upper === 'POST') return 'velu-openapi-method-badge velu-openapi-method-post';
+  if (upper === 'PUT') return 'velu-openapi-method-badge velu-openapi-method-put';
+  if (upper === 'PATCH') return 'velu-openapi-method-badge velu-openapi-method-patch';
+  if (upper === 'DELETE') return 'velu-openapi-method-badge velu-openapi-method-delete';
+  if (upper === 'WEBHOOK') return 'velu-openapi-method-badge velu-openapi-method-webhook';
+  return 'velu-openapi-method-badge velu-openapi-method-get';
+}
+
+function parseOperationReference(value: string, requireUppercaseMethod = false): { method: string; target: string } | null {
+  const trimmed = value.trim();
+  if (!trimmed) return null;
+  const withSpec = trimmed.match(/^(\S+)\s+([A-Za-z]+)\s+(.+)$/);
+  if (withSpec) {
+    const rawMethod = withSpec[2];
+    const method = withSpec[2].toUpperCase();
+    if (requireUppercaseMethod && rawMethod !== method) return null;
+    if (!OPENAPI_METHODS.has(method)) return null;
+    return { method, target: withSpec[3].trim() };
+  }
+  const noSpec = trimmed.match(/^([A-Za-z]+)\s+(.+)$/);
+  if (noSpec) {
+    const rawMethod = noSpec[1];
+    const method = noSpec[1].toUpperCase();
+    if (requireUppercaseMethod && rawMethod !== method) return null;
+    if (!OPENAPI_METHODS.has(method)) return null;
+    return { method, target: noSpec[2].trim() };
+  }
+  return null;
+}
+
+function stripMethodPrefix(name: string, method: string): string {
+  const regex = new RegExp(`^${method}\\s+`, 'i');
+  return name.replace(regex, '').trim();
+}
+
+function openApiSidebarMethodBadgePlugin() {
+  return {
+    name: 'velu:openapi-sidebar-method-badge',
+    transformPageTree: {
+      file(node: Record<string, unknown>, filePath?: string) {
+        let data: Record<string, unknown> = {};
+        if (filePath) {
+          const file = (this as { storage?: { read?: (path: string) => unknown } }).storage?.read?.(filePath) as
+            | { format?: string; data?: Record<string, unknown> }
+            | undefined;
+          if (file?.format === 'page') data = file.data ?? {};
+        }
+
+        const nameCandidate = typeof node.name === 'string' ? node.name.trim() : '';
+        const titleCandidate = typeof data.title === 'string' ? data.title.trim() : '';
+        const openApiCandidate = typeof data.openapi === 'string' ? data.openapi.trim() : '';
+        const parsed = openApiCandidate
+          ? parseOperationReference(openApiCandidate)
+          : parseOperationReference(nameCandidate, true) ?? parseOperationReference(titleCandidate, true);
+        if (!parsed) return node;
+
+        const method = parsed.method;
+        const rawName = nameCandidate || titleCandidate || parsed.target;
+        const text = stripMethodPrefix(rawName, method) || parsed.target || rawName || method;
+        const stableIdRaw = filePath || openApiCandidate || rawName || `${method}-${parsed.target}`;
+        const stableId = stableIdRaw.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '');
+
+        node.name = createElement(
+          'span',
+          { className: 'velu-openapi-sidebar-item', key: `openapi-item-${stableId || 'unknown'}` },
+          createElement(
+            'span',
+            { className: methodBadgeClass(method), key: `openapi-item-${stableId || 'unknown'}-method` },
+            method,
+          ),
+          createElement(
+            'span',
+            { className: 'velu-openapi-sidebar-label', key: `openapi-item-${stableId || 'unknown'}-label` },
+            text,
+          ),
+        );
+        return node;
+      },
+    },
+  };
+}
 
 export const source = loader({
   baseUrl: '/',
-  source: docs.toFumadocsSource(),
-  plugins: [lucideIconsPlugin()],
+  source: docsCollection.toFumadocsSource() as any,
+  plugins: [
+    openApiSidebarMethodBadgePlugin() as any,
+    statusBadgesPlugin({
+      renderBadge: (status: string) => {
+        const normalized = status.trim().toLowerCase();
+        const label = normalized === 'deprecated' ? 'Deprecated' : status;
+        const className = normalized === 'deprecated'
+          ? 'velu-status-badge velu-status-badge-deprecated'
+          : 'velu-status-badge';
+        return createElement('span', { className, 'data-status': normalized }, label);
+      },
+    }),
+  ],
   i18n:
     languages.length > 1
       ? {