loly 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,458 @@
+import { Express } from 'express';
+export { B as BootstrapOptions, C as ClientRouteLoaded, b as bootstrapClient } from './bootstrap-DgWagZ79.js';
+export { Image, ImageProps } from './components.js';
+import 'loly-jsx';
+
+/**
+ * Route segment types
+ */
+interface RouteSegment {
+    segment: string;
+    isDynamic: boolean;
+    isCatchAll: boolean;
+    isOptional: boolean;
+    paramName?: string;
+}
+/**
+ * Route file information
+ */
+interface RouteFile {
+    filePath: string;
+    segments: RouteSegment[];
+    type: "page" | "layout" | "route";
+    isRootLayout: boolean;
+    urlPath: string;
+    isApiRoute?: boolean;
+    httpMethods?: string[];
+}
+/**
+ * Route configuration
+ */
+interface RouteConfig {
+    routes: RouteFile[];
+    rootLayout: RouteFile | undefined;
+    routeMap: Map<string, RouteFile>;
+    apiRouteMap?: Map<string, RouteFile>;
+}
+/**
+ * Page component props
+ */
+interface PageProps {
+    params: Record<string, string>;
+    searchParams: Record<string, string>;
+}
+/**
+ * Layout component props
+ */
+interface LayoutProps {
+    children: any;
+    params: Record<string, string>;
+}
+
+/**
+ * Scan src/app/ directory and generate route configuration
+ */
+declare function scanRoutes(appDir: string): Promise<RouteConfig>;
+
+/**
+ * Match a URL pathname to a route
+ */
+declare function matchRoute(pathname: string, config: RouteConfig, loadComponent: (route: RouteFile) => Promise<any>): {
+    route: RouteFile;
+    params: Record<string, string>;
+} | null;
+/**
+ * Extract params from pathname for a matched route
+ */
+declare function extractParams(pathname: string, route: RouteFile): Record<string, string>;
+
+/**
+ * Manifest route entry with compiled paths and chunks
+ */
+interface ManifestRouteEntry {
+    path: string;
+    sourcePath: string;
+    serverPath?: string;
+    segments: RouteFile["segments"];
+    type: RouteFile["type"];
+    isRootLayout: boolean;
+    urlPath: string;
+    isApiRoute?: boolean;
+    httpMethods?: string[];
+    clientChunks?: {
+        js: string[];
+        css: string[];
+    };
+}
+/**
+ * Root layout manifest entry
+ */
+interface RootLayoutManifest {
+    sourcePath: string;
+    serverPath?: string;
+    segments: RouteFile["segments"];
+    type: "layout";
+    isRootLayout: boolean;
+    urlPath: string;
+}
+/**
+ * Route configuration with manifest data
+ */
+interface RouteConfigWithManifest {
+    routeMapManifest?: Map<string, ManifestRouteEntry>;
+    rootLayoutManifest?: RootLayoutManifest;
+    routesManifest?: ManifestRouteEntry[];
+}
+
+interface SSRContext {
+    pathname: string;
+    searchParams: Record<string, string>;
+    params: Record<string, string>;
+}
+interface SSRResult {
+    html: ReadableStream<Uint8Array>;
+    status: number;
+}
+/**
+ * Render page content (without full HTML wrapper) - used for RSC endpoint
+ */
+declare function renderPageContent(context: SSRContext, config: RouteConfig, appDir: string): Promise<{
+    html: string;
+    scripts: string;
+    styles: string;
+    preloads: string;
+    islandData: Record<string, any>;
+}>;
+/**
+ * Render a page using streaming
+ */
+declare function renderPageStream(context: SSRContext, config: RouteConfig, appDir: string): Promise<SSRResult>;
+
+/**
+ * Handler for RSC endpoint
+ */
+type RSCHandler = (pathname: string, searchParams: Record<string, string>) => Promise<{
+    html: string;
+    scripts: string;
+    styles: string;
+    preloads: string;
+    islandData?: Record<string, any>;
+    params: Record<string, string>;
+}>;
+/**
+ * Handler for SSR endpoint
+ */
+type SSRHandler = (pathname: string, searchParams: Record<string, string>) => Promise<SSRResult>;
+
+/**
+ * Abstract base server class using Template Method pattern
+ * Defines the skeleton of server setup algorithm
+ */
+declare abstract class BaseServer {
+    protected app: Express;
+    protected port: number;
+    constructor(port?: number);
+    /**
+     * Template method - defines the algorithm structure
+     */
+    setup(): Promise<void>;
+    /**
+     * Setup Express middleware
+     */
+    protected setupMiddleware(): void;
+    /**
+     * Setup static file serving
+     */
+    protected setupStaticFiles(): void;
+    /**
+     * Setup image optimization endpoint
+     */
+    protected setupImageEndpoint(): void;
+    /**
+     * Setup async component endpoint
+     */
+    protected setupAsyncEndpoint(): void;
+    /**
+     * Setup API routes
+     */
+    protected setupApiRoutes(): void;
+    /**
+     * Setup RSC endpoint
+     */
+    protected setupRSCEndpoint(): void;
+    /**
+     * Setup SSR endpoint
+     */
+    protected setupSSREndpoint(): void;
+    /**
+     * Create RSC handler - to be implemented by subclasses
+     */
+    protected abstract createRSCHandler(): RSCHandler;
+    /**
+     * Create SSR handler - to be implemented by subclasses
+     */
+    protected abstract createSSRHandler(): SSRHandler;
+    /**
+     * Load route configuration - to be implemented by subclasses
+     */
+    protected abstract loadRouteConfig(): Promise<RouteConfig>;
+    /**
+     * Start the server
+     */
+    start(): Promise<void>;
+    /**
+     * Get the Express app instance
+     */
+    getApp(): Express;
+}
+
+interface DevServerOptions {
+    projectDir: string;
+    port?: number;
+}
+/**
+ * Development server class
+ * Extends BaseServer with hot reload capabilities
+ */
+declare class DevServer extends BaseServer {
+    private projectDir;
+    private watcher;
+    constructor(options: DevServerOptions);
+    /**
+     * Initialize server context and load routes
+     */
+    initialize(): Promise<void>;
+    /**
+     * Create RSC handler
+     */
+    protected createRSCHandler(): RSCHandler;
+    /**
+     * Create SSR handler
+     */
+    protected createSSRHandler(): SSRHandler;
+    /**
+     * Load route configuration
+     */
+    protected loadRouteConfig(): Promise<RouteConfig>;
+    /**
+     * Setup hot reload watcher
+     */
+    private setupHotReload;
+    /**
+     * Start the development server with hot reload
+     */
+    start(): Promise<void>;
+    /**
+     * Stop the server and cleanup
+     */
+    stop(): Promise<void>;
+}
+/**
+ * Convenience function to start development server
+ * Maintains backward compatibility
+ */
+declare function startDevServer(options: DevServerOptions): Promise<void>;
+
+interface ProdServerOptions {
+    projectDir: string;
+    port?: number;
+}
+/**
+ * Production server class
+ * Extends BaseServer with manifest-based route loading
+ */
+declare class ProdServer extends BaseServer {
+    private projectDir;
+    private config;
+    constructor(options: ProdServerOptions);
+    /**
+     * Initialize server context and load routes from manifest
+     */
+    initialize(): Promise<void>;
+    /**
+     * Create RSC handler
+     */
+    protected createRSCHandler(): RSCHandler;
+    /**
+     * Create SSR handler
+     */
+    protected createSSRHandler(): SSRHandler;
+    /**
+     * Load route configuration from manifest
+     */
+    protected loadRouteConfig(): Promise<RouteConfig>;
+    /**
+     * Start the production server
+     */
+    start(): Promise<void>;
+}
+/**
+ * Convenience function to start production server
+ * Maintains backward compatibility
+ */
+declare function startProdServer(options: ProdServerOptions): Promise<void>;
+
+/**
+ * Factory for loading route and layout components
+ * Centralizes component loading logic with caching support
+ */
+declare class RouteComponentFactory {
+    private componentCache;
+    private layoutCache;
+    /**
+     * Load a route component
+     * @param route - Route file information
+     * @param compiledPath - Optional compiled path for production
+     * @returns The loaded component module
+     */
+    loadRouteComponent(route: RouteFile, compiledPath?: string): Promise<any>;
+    /**
+     * Load a layout component
+     * @param layout - Layout route file information
+     * @param compiledPath - Optional compiled path for production
+     * @returns The loaded layout component module
+     */
+    loadLayoutComponent(layout: RouteFile, compiledPath?: string): Promise<any>;
+    /**
+     * Load all layouts from root to route
+     * @param route - Target route file
+     * @param config - Route configuration
+     * @param appDir - Application directory
+     * @param manifestRoute - Optional manifest route data
+     * @returns Array of layout components in order (root to route)
+     */
+    loadLayouts(route: RouteFile, config: RouteConfig, appDir: string, manifestRoute?: ManifestRouteEntry): Promise<Array<(props: {
+        children: any;
+        params: Record<string, string>;
+    }) => any>>;
+    /**
+     * Clear component cache
+     */
+    clearCache(): void;
+}
+
+/**
+ * Rendering strategy interface for SSR
+ * Defines the contract for different rendering approaches
+ */
+interface RenderingStrategy {
+    /**
+     * Render content based on the strategy
+     * @param context - SSR context with pathname, searchParams, etc.
+     * @param config - Route configuration
+     * @returns Rendering result with HTML and status
+     */
+    render(context: SSRContext, config: RouteConfig): Promise<SSRResult>;
+}
+/**
+ * RSC rendering result
+ */
+interface RSCRenderingResult {
+    html: string;
+    scripts: string;
+    styles: string;
+    preloads: string;
+    islandData: Record<string, any>;
+}
+/**
+ * RSC (React Server Components) Strategy
+ * Renders page content without full HTML wrapper for SPA navigation
+ */
+declare class RSCStrategy {
+    private routeFactory;
+    constructor(routeFactory: RouteComponentFactory);
+    render(context: SSRContext, config: RouteConfig): Promise<RSCRenderingResult>;
+}
+/**
+ * SSR (Server-Side Rendering) Strategy
+ * Renders full HTML document with head, body, scripts, and styles
+ */
+declare class SSRStrategy implements RenderingStrategy {
+    private routeFactory;
+    constructor(routeFactory: RouteComponentFactory);
+    render(context: SSRContext, config: RouteConfig): Promise<SSRResult>;
+}
+/**
+ * Factory for creating rendering strategies
+ */
+declare class RenderingStrategyFactory {
+    private routeFactory;
+    constructor(routeFactory: RouteComponentFactory);
+    /**
+     * Get SSR rendering strategy
+     * @returns SSR rendering strategy
+     */
+    getSSRStrategy(): SSRStrategy;
+    /**
+     * Get RSC rendering strategy
+     * @returns RSC rendering strategy
+     */
+    getRSCStrategy(): RSCStrategy;
+    /**
+     * Get rendering strategy based on type
+     * @param type - Strategy type: 'ssr' or 'rsc'
+     * @returns Appropriate rendering strategy (SSR only, RSC must be accessed via getRSCStrategy)
+     */
+    getStrategy(type: "ssr"): RenderingStrategy;
+}
+
+interface BuildOptions {
+    projectDir: string;
+    outDir?: string;
+    mode?: "development" | "production";
+}
+/**
+ * Execute the build
+ */
+declare function buildProject(options: BuildOptions): Promise<void>;
+
+/**
+ * Generate routes manifest for client
+ */
+declare function generateRoutesManifest(config: RouteConfig, projectDir: string, appDir: string): void;
+/**
+ * Generate bootstrap.ts file for client
+ */
+declare function generateBootstrap(projectDir: string, routes: any[]): void;
+/**
+ * Read Rspack manifest
+ */
+interface ChunkManifest {
+    [key: string]: {
+        file: string;
+        isEntry?: boolean;
+        imports?: string[];
+        css?: string[];
+    };
+}
+declare function readRspackManifest(manifestPath: string): ChunkManifest;
+/**
+ * Write manifest
+ */
+declare function writeManifest(manifestPath: string, manifest: ChunkManifest): void;
+/**
+ * Generate asset tags from manifest
+ */
+declare function generateAssetTags(manifest: ChunkManifest, entryName: string, publicPath: string): {
+    scripts: string;
+    styles: string;
+    preloads: string;
+};
+
+/**
+ * Extract public environment variables (LOLY_PUBLIC_*)
+ * These variables will be available in the client
+ */
+declare function getPublicEnv(): Record<string, string>;
+/**
+ * Generate script tag to inject public env variables into client
+ */
+declare function generatePublicEnvScript(): string;
+/**
+ * Get public environment variable (works in both server and client)
+ * In server: reads from process.env (with or without LOLY_PUBLIC_ prefix)
+ * In client: reads from window.__LOLY_ENV__
+ */
+declare function getEnv(key: string): string | undefined;
+
+export { BaseServer, type ChunkManifest, DevServer, type LayoutProps, type ManifestRouteEntry, type PageProps, ProdServer, type RSCRenderingResult, RSCStrategy, type RenderingStrategy, RenderingStrategyFactory, type RootLayoutManifest, RouteComponentFactory, type RouteConfig, type RouteConfigWithManifest, type RouteFile, type RouteSegment, type SSRContext, type SSRResult, SSRStrategy, buildProject, extractParams, generateAssetTags, generateBootstrap, generatePublicEnvScript, generateRoutesManifest, getEnv, getPublicEnv, matchRoute, readRspackManifest, renderPageContent, renderPageStream, scanRoutes, startDevServer, startProdServer, writeManifest };