olova 2.0.61 → 2.0.63

package/src/scanner/index.ts

@@ -1,114 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-import type { ErrorEntry, LayoutEntry, LoadingEntry, MiddlewareEntry, NotFoundEntry, RouteEntry, ScanResult } from '../types';
-import { isRouteGroup, pathToRoute } from '../utils';
-
-const RESERVED_NAMES = new Set([
-  'page', 'layout', 'loading', 'error', 'not-found', 'middleware',
-  'route.tree',
-]);
-
-function scanDirectory(
-  dir: string,
-  rootDir: string,
-  extensions: string[],
-  routes: RouteEntry[],
-  notFoundPages: NotFoundEntry[],
-  layouts: LayoutEntry[],
-  loadingPages: LoadingEntry[],
-  errorPages: ErrorEntry[],
-  middlewares: MiddlewareEntry[],
-  isRoot = false
-) {
-  if (!fs.existsSync(dir)) return;
-
-  const entries = fs.readdirSync(dir, { withFileTypes: true });
-
-  for (const entry of entries) {
-    const fullPath = path.join(dir, entry.name);
-
-    if (entry.isDirectory()) {
-      if (entry.name === 'node_modules' || entry.name === 'assets' || entry.name.startsWith('_')) continue;
-      scanDirectory(fullPath, rootDir, extensions, routes, notFoundPages, layouts, loadingPages, errorPages, middlewares, false);
-    } else if (entry.isFile()) {
-      const ext = path.extname(entry.name);
-      const baseName = path.basename(entry.name, ext);
-
-      if (baseName === 'layout' && extensions.includes(ext)) {
-        const relativePath = path.relative(rootDir, dir);
-        const { routePath } = pathToRoute(relativePath, path.sep);
-        layouts.push({
-          path: isRoot ? '/' : routePath,
-          filePath: fullPath
-        });
-      }
-      else if (baseName === 'loading' && extensions.includes(ext)) {
-        const relativePath = path.relative(rootDir, dir);
-        const { routePath } = pathToRoute(relativePath, path.sep);
-        loadingPages.push({
-          path: isRoot ? '/' : routePath,
-          filePath: fullPath
-        });
-      }
-      else if (baseName === 'error' && extensions.includes(ext)) {
-        const relativePath = path.relative(rootDir, dir);
-        const { routePath } = pathToRoute(relativePath, path.sep);
-        errorPages.push({
-          path: isRoot ? '/' : routePath,
-          filePath: fullPath
-        });
-      }
-      else if (baseName === 'middleware' && extensions.includes(ext)) {
-        const relativePath = path.relative(rootDir, dir);
-        const { routePath } = pathToRoute(relativePath, path.sep);
-        middlewares.push({
-          path: isRoot ? '/' : routePath,
-          filePath: fullPath
-        });
-      }
-      else if ((baseName === 'not-found' || baseName === '404') && extensions.includes(ext)) {
-        const relativeParts = path.relative(rootDir, dir).split(path.sep).filter(Boolean);
-        const filteredParts = relativeParts.filter(p => !isRouteGroup(p));
-        const pathPrefix = isRoot ? '' : '/' + filteredParts.join('/');
-        notFoundPages.push({ pathPrefix: pathPrefix || '', filePath: fullPath });
-      } else if (baseName === 'page' && extensions.includes(ext)) {
-        const relativePath = path.relative(rootDir, dir);
-        const { routePath, params } = pathToRoute(relativePath, path.sep);
-        routes.push({ path: routePath, filePath: fullPath, isDynamic: params.length > 0, params });
-      } else if (
-        !RESERVED_NAMES.has(baseName) &&
-        !baseName.endsWith('.d') &&
-        !baseName.startsWith('_') &&
-        extensions.includes(ext)
-      ) {
-        const relativePath = path.relative(rootDir, fullPath);
-        const relativePathNoExt = relativePath.substring(0, relativePath.length - ext.length);
-        const { routePath, params } = pathToRoute(relativePathNoExt, path.sep);
-        routes.push({ path: routePath, filePath: fullPath, isDynamic: params.length > 0, params });
-      }
-    }
-  }
-}
-
-export function scanRoutes(rootDir: string, extensions: string[]): ScanResult {
-  const routes: RouteEntry[] = [];
-  const notFoundPages: NotFoundEntry[] = [];
-  const layouts: LayoutEntry[] = [];
-  const loadingPages: LoadingEntry[] = [];
-  const errorPages: ErrorEntry[] = [];
-  const middlewares: MiddlewareEntry[] = [];
-  const absoluteRoot = path.isAbsolute(rootDir) ? rootDir : path.resolve(rootDir);
-
-  if (!fs.existsSync(absoluteRoot)) {
-    throw new Error(`Olova Router: Root directory does not exist: ${absoluteRoot}`);
-  }
-
-  scanDirectory(absoluteRoot, absoluteRoot, extensions, routes, notFoundPages, layouts, loadingPages, errorPages, middlewares, true);
-  routes.sort((a, b) => (a.isDynamic !== b.isDynamic ? (a.isDynamic ? 1 : -1) : a.path.localeCompare(b.path)));
-  notFoundPages.sort((a, b) => b.pathPrefix.length - a.pathPrefix.length);
-  layouts.sort((a, b) => a.path.length - b.path.length);
-  loadingPages.sort((a, b) => b.path.length - a.path.length);
-  errorPages.sort((a, b) => b.path.length - a.path.length);
-  middlewares.sort((a, b) => a.path.length - b.path.length);
-  return { routes, notFoundPages, layouts, loadingPages, errorPages, middlewares };
-}

package/src/types/index.ts

@@ -1,190 +0,0 @@
-import type { ComponentType, ReactNode } from 'react';
-export type { PluginOption, ResolvedConfig } from 'vite';
-
-export interface RouteEntry {
-  path: string;
-  filePath: string;
-  isDynamic: boolean;
-  params: string[];
-}
-
-export interface ScannerOptions {
-  rootDir: string;
-  extensions: string[];
-}
-
-export interface Metadata {
-  title?: string;
-  description?: string;
-  keywords?: string[];
-  openGraph?: {
-    title?: string;
-    description?: string;
-    image?: string;
-    url?: string;
-    type?: string;
-  };
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  [key: string]: any;
-}
-
-export interface RouteConfig {
-  path: string;
-  component: string;
-  params?: string[];
-  metadata?: Metadata;
-}
-
-export interface GeneratorOptions {
-  routes: RouteEntry[];
-  basePath: string;
-}
-
-export interface OlovaRouterOptions {
-  extensions?: string[];
-  packageName?: string;
-}
-
-export interface DynamicSegmentResult {
-  isDynamic: boolean;
-  paramName: string | null;
-}
-
-export interface NotFoundEntry {
-  pathPrefix: string;
-  filePath: string;
-}
-
-export interface NotFoundPageConfig {
-  pathPrefix: string;
-  component: ComponentType;
-  metadata?: Metadata;
-}
-
-export interface LayoutEntry {
-  path: string;
-  filePath: string;
-}
-
-export interface LoadingEntry {
-  path: string;
-  filePath: string;
-}
-
-export interface ErrorEntry {
-  path: string;
-  filePath: string;
-}
-
-export interface MiddlewareEntry {
-  path: string;
-  filePath: string;
-}
-
-export interface ScanResult {
-  routes: RouteEntry[];
-  notFoundPages: NotFoundEntry[];
-  layouts: LayoutEntry[];
-  loadingPages: LoadingEntry[];
-  errorPages: ErrorEntry[];
-  middlewares: MiddlewareEntry[];
-}
-
-export interface RouteWithExport extends RouteConfig {
-  hasDefault: boolean;
-  namedExport: string | null;
-  hasMetadata: boolean;
-  metadataSource?: string;
-  hasRoute: boolean;
-  hasGetStaticPaths: boolean;
-  hasLoader: boolean;
-}
-
-export interface NotFoundWithExport extends NotFoundEntry {
-  hasDefault: boolean;
-  namedExport: string | null;
-  hasMetadata: boolean;
-}
-
-export interface LayoutWithExport extends LayoutEntry {
-  hasDefault: boolean;
-  namedExport: string | null;
-  hasMetadata: boolean;
-}
-
-export interface LoadingWithExport extends LoadingEntry {
-  hasDefault: boolean;
-  namedExport: string | null;
-}
-
-export interface ErrorWithExport extends ErrorEntry {
-  hasDefault: boolean;
-  namedExport: string | null;
-}
-
-export interface MiddlewareWithExport extends MiddlewareEntry {
-  hasDefault: boolean;
-  namedExport: string | null;
-}
-
-export interface RouteErrorProps {
-  error: Error;
-  reset: () => void;
-}
-
-export interface LoaderContext {
-  request: Request;
-  params: Record<string, string>;
-}
-
-export interface Route {
-  id?: string;
-  path: string;
-  component?: ComponentType;
-  metadata?: Metadata;
-  loading?: ComponentType;
-  error?: ComponentType<RouteErrorProps>;
-  filePath?: string;
-  params?: string[];
-  loader?: (ctx: LoaderContext) => Promise<Record<string, unknown>>;
-}
-
-export interface LayoutRoute {
-  path: string;
-  layout?: ComponentType;
-  children: Route[];
-  metadata?: Metadata;
-}
-
-export type SearchParams = Record<string, string | string[]>;
-
-export interface SetSearchParamsOptions {
-  replace?: boolean;
-  merge?: boolean;
-}
-
-export interface NavigateOptions {
-  scroll?: boolean;
-  replace?: boolean;
-}
-
-export type NavigationListener = (from: string, to: string) => void | boolean;
-
-export interface RouterContextType {
-  currentPath: string;
-  params: Record<string, string>;
-  searchParams: SearchParams;
-  navigate: (path: string, options?: NavigateOptions) => void;
-  push: (path: string, options?: NavigateOptions) => void;
-  replace: (path: string, options?: NavigateOptions) => void;
-  back: () => void;
-  forward: () => void;
-  refresh: () => void;
-  setSearchParams: (params: Record<string, string | string[] | null>, options?: SetSearchParamsOptions) => void;
-  isNavigating: boolean;
-  prefetch: (path: string) => void;
-}
-
-export interface OutletContextType {
-  content: ReactNode;
-}

package/src/utils/export.ts

@@ -1,85 +0,0 @@
-import fs from 'fs';
-
-function extractBalancedBraces(content: string, startIndex: number): string | null {
-  if (content[startIndex] !== '{') return null;
-  let depth = 0;
-  for (let i = startIndex; i < content.length; i++) {
-    if (content[i] === '{') depth++;
-    else if (content[i] === '}') {
-      depth--;
-      if (depth === 0) return content.substring(startIndex, i + 1);
-    }
-  }
-  return null;
-}
-
-function extractMetadataSource(content: string): string | undefined {
-  const match = content.match(/export\s+(?:const|let|var)\s+metadata\s*(?::\s*\w+\s*)?=\s*/);
-  if (!match || match.index === undefined) return undefined;
-  const afterEquals = match.index + match[0].length;
-  return extractBalancedBraces(content, afterEquals) || undefined;
-}
-
-export function detectExportType(filePath: string): {
-  hasDefault: boolean;
-  namedExport: string | null;
-  hasMetadata: boolean;
-  metadataSource?: string;
-  hasRoute: boolean;
-  hasGetStaticPaths: boolean;
-  hasLoader: boolean;
-} {
-  try {
-    const content = fs.readFileSync(filePath, 'utf-8');
-
-    const hasMetadata = /export\s+(?:const|let|var)\s+metadata\s*/.test(content) ||
-                       /export\s*\{\s*metadata\s*\}/.test(content);
-
-    const hasRoute = /export\s+(?:const|let|var)\s+route\s*=/.test(content) ||
-                    /export\s*\{\s*route\s*\}/.test(content);
-
-    const hasGetStaticPaths = /export\s+(?:async\s+)?function\s+getStaticPaths/.test(content) ||
-                              /export\s+(?:const|let|var)\s+getStaticPaths\s*=/.test(content) ||
-                              /export\s*\{[^}]*getStaticPaths[^}]*\}/.test(content);
-
-    const hasLoader = /export\s+(?:async\s+)?function\s+loader/.test(content) ||
-                      /export\s+(?:const|let|var)\s+loader\s*=/.test(content) ||
-                      /export\s*\{[^}]*loader[^}]*\}/.test(content);
-
-    // Extract metadata source for inlining (works for any file type with object literal metadata)
-    const metadataSource = extractMetadataSource(content);
-
-    if (filePath.toLowerCase().endsWith('.mdx')) {
-      return {
-        hasDefault: true,
-        namedExport: null,
-        hasMetadata: !!metadataSource,
-        hasRoute: false,
-        hasGetStaticPaths: false,
-        hasLoader: false,
-        metadataSource
-      };
-    }
-
-    if (/export\s+default\s+/.test(content)) {
-      return { hasDefault: true, namedExport: null, hasMetadata, metadataSource, hasRoute, hasGetStaticPaths, hasLoader };
-    }
-
-    const namedMatch = content.match(/export\s+(?:const|function|class)\s+(\w+)/);
-    if (namedMatch) {
-      return { hasDefault: false, namedExport: namedMatch[1], hasMetadata, metadataSource, hasRoute, hasGetStaticPaths, hasLoader };
-    }
-
-    const exportMatch = content.match(/export\s*\{\s*(\w+)(?:\s+as\s+default)?\s*\}/);
-    if (exportMatch) {
-      if (content.includes('as default')) {
-        return { hasDefault: true, namedExport: null, hasMetadata, metadataSource, hasRoute, hasGetStaticPaths, hasLoader };
-      }
-      return { hasDefault: false, namedExport: exportMatch[1], hasMetadata, metadataSource, hasRoute, hasGetStaticPaths, hasLoader };
-    }
-
-    return { hasDefault: false, namedExport: null, hasMetadata, metadataSource, hasRoute, hasGetStaticPaths, hasLoader };
-  } catch {
-    return { hasDefault: true, namedExport: null, hasMetadata: false, hasRoute: false, hasGetStaticPaths: false, hasLoader: false };
-  }
-}

package/src/utils/index.ts

@@ -1,4 +0,0 @@
-export { detectExportType } from './export';
-export { getRouteName } from './naming';
-export { isRouteGroup, parseDynamicSegment, pathToRoute } from './path';
-

package/src/utils/naming.ts

@@ -1,54 +0,0 @@
-export function getRouteName(path: string): string {
-  if (path === '/' || path === '') return 'Root';
-  
-  // Remove leading/trailing slashes and split
-  const segments = path.replace(/^\/|\/$/g, '').split(/[\\/]/);
-  
-  const nameSegments = segments.map(segment => {
-    let cleanSegment = segment;
-    
-    // Handle dynamic segments :id -> Id
-    if (cleanSegment.startsWith(':')) {
-      cleanSegment = cleanSegment.slice(1);
-    }
-    
-    // Handle bracket syntax [id] -> Id, [...slug] -> Slug
-    if (cleanSegment.startsWith('[') && cleanSegment.endsWith(']')) {
-      cleanSegment = cleanSegment.slice(1, -1);
-      if (cleanSegment.startsWith('...')) {
-        cleanSegment = cleanSegment.slice(3);
-      }
-    }
-
-    // Handle catch-all * -> All
-    if (cleanSegment === '*') {
-      return 'All';
-    }
-
-    // Skip 'index' segment for cleaner names
-    if (cleanSegment.toLowerCase() === 'index') {
-      return '';
-    }
-
-    // Handle route groups (auth) -> Auth or ignore? Usually people ignore path but name might want it?
-    // User request is about "main folder name". (auth) is usually invisible.
-    // Let's strip parens but keep name for uniqueness? Or just strip?
-    // scanner often treats (group) as transparent for path, but for Naming it might be good to include or exclude.
-    // Let's include it cleaned up to ensure Uniqueness (e.g. /app/(dashboard)/layout vs /app/(marketing)/layout).
-    if (cleanSegment.startsWith('(') && cleanSegment.endsWith(')')) {
-      cleanSegment = cleanSegment.slice(1, -1);
-    }
-    
-    return capitalize(cleanSegment);
-  });
-
-  const finalName = nameSegments.join('');
-  if (/^\d/.test(finalName)) {
-    return 'Page' + finalName;
-  }
-  return finalName;
-}
-
-function capitalize(str: string): string {
-  return str.charAt(0).toUpperCase() + str.slice(1).replace(/[^a-zA-Z0-9]/g, '');
-}

package/src/utils/path.ts

@@ -1,45 +0,0 @@
-import type { DynamicSegmentResult } from '../types';
-
-export function parseDynamicSegment(segment: string): DynamicSegmentResult & { isCatchAll: boolean } {
-  if (segment.match(/^\[\.\.\.(.+)\]$/)) {
-    const paramName = segment.match(/^\[\.\.\.(.+)\]$/)?.[1] || 'slug';
-    return { isDynamic: true, paramName, isCatchAll: true };
-  }
-
-  const bracketMatch = segment.match(/^\[(.+)\]$/);
-  if (bracketMatch) {
-    return { isDynamic: true, paramName: bracketMatch[1], isCatchAll: false };
-  }
-
-
-
-  return { isDynamic: false, paramName: null, isCatchAll: false };
-}
-
-export function isRouteGroup(segment: string): boolean {
-  return /^\(.+\)$/.test(segment);
-}
-
-export function pathToRoute(relativePath: string, sep: string) {
-  const params: string[] = [];
-  let hasCatchAll = false;
-  const segments = relativePath.split(sep).filter(Boolean);
-
-  const routeSegments = segments
-    .filter(segment => !isRouteGroup(segment))
-    .map(segment => {
-      const { isDynamic, paramName, isCatchAll } = parseDynamicSegment(segment);
-      if (isDynamic && paramName) {
-        params.push(paramName);
-        if (isCatchAll) {
-          hasCatchAll = true;
-          return `*`;
-        }
-        return `:${paramName}`;
-      }
-      return segment;
-    });
-
-  const routePath = '/' + routeSegments.join('/');
-  return { routePath: routePath === '/' ? '/' : routePath, params, hasCatchAll };
-}

package/tsup.config.ts

@@ -1,35 +0,0 @@
-import { defineConfig } from 'tsup';
-
-export default defineConfig({
-  entry: {
-    'olova': 'olova.ts',
-    'main': 'src/main.tsx',
-    'entry-server': 'src/entry-server.tsx',
-    'entry-worker': 'src/entry-worker.tsx',
-    'performance': 'src/performance.ts',
-    'router': 'src/router/router.tsx',
-  },
-  format: ['cjs', 'esm'],
-  dts: {
-    entry: {
-      'olova': 'olova.ts',
-      'router': 'src/router/router.tsx',
-    }
-  },
-  clean: true,
-  shims: true,
-  platform: 'node',
-  external: [
-    'vite',
-    'react',
-    'react-dom',
-    'react-dom/client',
-    'react-dom/server',
-    'virtual:olova-app',  // External - resolved at runtime by plugin
-    '/src/index.css'     // External - resolved by Vite in user project
-  ],
-  treeshake: true,
-  sourcemap: true,
-  minify: false,
-  target: 'node18',
-});