olova 2.0.55 → 2.0.56

package/src/scanner/index.ts

@@ -0,0 +1,116 @@
+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([
+  'index', 'layout', 'loading', 'error', '404', 'middleware',
+  'App', 'main', '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 === '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 (isRoot && baseName === 'App' && extensions.includes(ext)) {
+        routes.push({ path: '/', filePath: fullPath, isDynamic: false, params: [] });
+      } else if (!isRoot && baseName === 'index' && extensions.includes(ext)) {
+        const relativePath = path.relative(rootDir, path.dirname(fullPath));
+        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

@@ -0,0 +1,191 @@
+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 {
+  rootDir?: string;
+  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

@@ -0,0 +1,85 @@
+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

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

package/src/utils/naming.ts

@@ -0,0 +1,54 @@
+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

@@ -0,0 +1,45 @@
+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

@@ -0,0 +1,35 @@
+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',
+});

package/CHANGELOG.md

@@ -1,31 +0,0 @@
-# Changelog
-
-All notable changes to this project will be documented in this file.
-
-The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
-and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
-
-## [0.1.0] - 2026-01-08
-
-### Added
-
-- Initial release of Olova
-- File-based routing with Next.js App Router conventions
-- `OlovaRouter` component for rendering routes
-- Vite plugin for automatic route generation
-- React hooks: `usePathname`, `useParams`, `useSearchParams`, `useRouter`
-- `Link` and `NavLink` components for client-side navigation
-- Error boundaries with `error.tsx` support
-- Loading states with `loading.tsx` support
-- 404 handling with `not-found.tsx` support
-- Dynamic routes with `[slug]` syntax
-- Catch-all routes with `[...slug]` syntax
-- Route groups with `(group)` syntax
-- Nested layouts support
-- TypeScript support with full type definitions
-- CLI for build commands
-
-### Known Limitations
-
-- SSG pre-rendering is not yet fully implemented
-- Parallel routes are experimental

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2026 sera
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.