@flexireact/core 1.0.0

package/core/server.js

@@ -0,0 +1,197 @@
+#!/usr/bin/env node
+
+import http from 'http';
+import path from 'path';
+import fs from 'fs';
+import { fileURLToPath } from 'url';
+import { buildRoutes, matchRoute } from './router.js';
+import { render, renderError } from './render.js';
+import { handleApiRoute } from './api.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// Configuration
+const PORT = process.env.PORT || 3000;
+const HOST = process.env.HOST || 'localhost';
+
+// Determine the project root (where the user's app is)
+const PROJECT_ROOT = process.cwd();
+const PAGES_DIR = path.join(PROJECT_ROOT, 'pages');
+
+// MIME types for static files
+const MIME_TYPES = {
+  '.html': 'text/html',
+  '.css': 'text/css',
+  '.js': 'application/javascript',
+  '.json': 'application/json',
+  '.png': 'image/png',
+  '.jpg': 'image/jpeg',
+  '.jpeg': 'image/jpeg',
+  '.gif': 'image/gif',
+  '.svg': 'image/svg+xml',
+  '.ico': 'image/x-icon',
+  '.woff': 'font/woff',
+  '.woff2': 'font/woff2',
+  '.ttf': 'font/ttf'
+};
+
+/**
+ * Creates and starts the FlexiReact dev server
+ */
+export function createServer(options = {}) {
+  const {
+    port = PORT,
+    host = HOST,
+    pagesDir = PAGES_DIR
+  } = options;
+
+  const server = http.createServer(async (req, res) => {
+    const startTime = Date.now();
+    
+    try {
+      // Parse URL
+      const url = new URL(req.url, `http://${req.headers.host}`);
+      const pathname = url.pathname;
+
+      // Log request
+      console.log(`${req.method} ${pathname}`);
+
+      // Try to serve static files from public directory
+      const publicPath = path.join(PROJECT_ROOT, 'public', pathname);
+      if (fs.existsSync(publicPath) && fs.statSync(publicPath).isFile()) {
+        return serveStaticFile(res, publicPath);
+      }
+
+      // Build routes (rebuild on each request for hot reload)
+      const routes = buildRoutes(pagesDir);
+
+      // Check for API routes first
+      const apiRoute = matchRoute(pathname, routes.api);
+      if (apiRoute) {
+        return await handleApiRoute(req, res, apiRoute);
+      }
+
+      // Check for page routes
+      const pageRoute = matchRoute(pathname, routes.pages);
+      if (pageRoute) {
+        return await handlePageRoute(req, res, pageRoute);
+      }
+
+      // 404 Not Found
+      res.writeHead(404, { 'Content-Type': 'text/html' });
+      res.end(renderError(404, 'Page not found'));
+
+    } catch (error) {
+      console.error('Server Error:', error);
+      
+      if (!res.headersSent) {
+        res.writeHead(500, { 'Content-Type': 'text/html' });
+        res.end(renderError(500, process.env.NODE_ENV === 'development' 
+          ? error.message 
+          : 'Internal Server Error'));
+      }
+    } finally {
+      const duration = Date.now() - startTime;
+      console.log(`  └─ ${res.statusCode} (${duration}ms)`);
+    }
+  });
+
+  server.listen(port, host, () => {
+    console.log('');
+    console.log('  ⚡ FlexiReact Dev Server');
+    console.log('  ─────────────────────────');
+    console.log(`  → Local:   http://${host}:${port}`);
+    console.log(`  → Pages:   ${pagesDir}`);
+    console.log('');
+    console.log('  Ready for requests...');
+    console.log('');
+  });
+
+  return server;
+}
+
+/**
+ * Handles page route requests with SSR
+ */
+async function handlePageRoute(req, res, route) {
+  try {
+    // Import the page component with cache busting for hot reload
+    const modulePath = `file://${route.filePath.replace(/\\/g, '/')}?t=${Date.now()}`;
+    const pageModule = await import(modulePath);
+    
+    // Get the component (default export)
+    const Component = pageModule.default;
+    
+    if (!Component) {
+      throw new Error(`No default export found in ${route.filePath}`);
+    }
+
+    // Get page props if getServerSideProps exists
+    let props = { params: route.params };
+    
+    if (pageModule.getServerSideProps) {
+      const context = {
+        params: route.params,
+        req,
+        res,
+        query: Object.fromEntries(new URL(req.url, `http://${req.headers.host}`).searchParams)
+      };
+      
+      const result = await pageModule.getServerSideProps(context);
+      
+      if (result.redirect) {
+        res.writeHead(result.redirect.statusCode || 302, {
+          Location: result.redirect.destination
+        });
+        res.end();
+        return;
+      }
+      
+      if (result.notFound) {
+        res.writeHead(404, { 'Content-Type': 'text/html' });
+        res.end(renderError(404, 'Page not found'));
+        return;
+      }
+      
+      props = { ...props, ...result.props };
+    }
+
+    // Get page title if defined
+    const title = pageModule.title || 'FlexiReact App';
+
+    // Render the page
+    const html = render(Component, props, { title });
+    
+    res.writeHead(200, { 'Content-Type': 'text/html' });
+    res.end(html);
+
+  } catch (error) {
+    console.error('Page Render Error:', error);
+    throw error;
+  }
+}
+
+/**
+ * Serves static files
+ */
+function serveStaticFile(res, filePath) {
+  const ext = path.extname(filePath).toLowerCase();
+  const contentType = MIME_TYPES[ext] || 'application/octet-stream';
+  
+  const content = fs.readFileSync(filePath);
+  res.writeHead(200, { 'Content-Type': contentType });
+  res.end(content);
+}
+
+// Auto-start server when run directly
+const scriptPath = process.argv[1];
+
+// Check if running directly (handles symlinks on Windows)
+const isDirectRun = scriptPath && scriptPath.endsWith('server.js');
+
+if (isDirectRun) {
+  createServer();
+}
+
+export default createServer;

package/core/ssg/index.js

@@ -0,0 +1,321 @@
+/**
+ * FlexiReact Static Site Generation (SSG)
+ * 
+ * SSG pre-renders pages at build time, generating static HTML files.
+ * This provides the fastest possible page loads and enables CDN caching.
+ * 
+ * Usage:
+ * - Export getStaticProps() from a page to fetch data at build time
+ * - Export getStaticPaths() for dynamic routes to specify which paths to pre-render
+ * - Pages without these exports are rendered as static HTML
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { pathToFileURL } from 'url';
+import { renderPage } from '../render/index.js';
+import { ensureDir, cleanDir } from '../utils.js';
+
+/**
+ * SSG Build Result
+ */
+export class SSGResult {
+  constructor() {
+    this.pages = [];
+    this.errors = [];
+    this.duration = 0;
+  }
+
+  addPage(path, file, size) {
+    this.pages.push({ path, file, size });
+  }
+
+  addError(path, error) {
+    this.errors.push({ path, error: error.message });
+  }
+
+  get success() {
+    return this.errors.length === 0;
+  }
+
+  get totalSize() {
+    return this.pages.reduce((sum, p) => sum + p.size, 0);
+  }
+}
+
+/**
+ * Generates static pages for all routes
+ */
+export async function generateStaticSite(options) {
+  const {
+    routes,
+    outDir,
+    config,
+    loadModule
+  } = options;
+
+  const result = new SSGResult();
+  const startTime = Date.now();
+
+  // Clean and create output directory
+  const staticDir = path.join(outDir, 'static');
+  cleanDir(staticDir);
+
+  console.log('\n📦 Generating static pages...\n');
+
+  for (const route of routes) {
+    try {
+      await generateRoutePage(route, staticDir, loadModule, result, config);
+    } catch (error) {
+      console.error(`  ✗ ${route.path}: ${error.message}`);
+      result.addError(route.path, error);
+    }
+  }
+
+  result.duration = Date.now() - startTime;
+
+  // Generate summary
+  console.log('\n' + '─'.repeat(50));
+  console.log(`  Generated ${result.pages.length} pages in ${result.duration}ms`);
+  if (result.errors.length > 0) {
+    console.log(`  ${result.errors.length} errors occurred`);
+  }
+  console.log('─'.repeat(50) + '\n');
+
+  return result;
+}
+
+/**
+ * Generates a single route's static page(s)
+ */
+async function generateRoutePage(route, outDir, loadModule, result, config) {
+  const module = await loadModule(route.filePath);
+  const Component = module.default;
+
+  if (!Component) {
+    throw new Error(`No default export in ${route.filePath}`);
+  }
+
+  // Check for getStaticPaths (dynamic routes)
+  let paths = [{ params: {} }];
+  
+  if (route.path.includes(':') || route.path.includes('*')) {
+    if (!module.getStaticPaths) {
+      console.log(`  ⊘ ${route.path} (dynamic, no getStaticPaths)`);
+      return;
+    }
+
+    const staticPaths = await module.getStaticPaths();
+    paths = staticPaths.paths || [];
+
+    if (staticPaths.fallback === false && paths.length === 0) {
+      console.log(`  ⊘ ${route.path} (no paths to generate)`);
+      return;
+    }
+  }
+
+  // Generate page for each path
+  for (const pathConfig of paths) {
+    const params = pathConfig.params || {};
+    const actualPath = substituteParams(route.path, params);
+
+    try {
+      // Get static props
+      let props = { params };
+      
+      if (module.getStaticProps) {
+        const staticProps = await module.getStaticProps({ params });
+        
+        if (staticProps.notFound) {
+          console.log(`  ⊘ ${actualPath} (notFound)`);
+          continue;
+        }
+        
+        if (staticProps.redirect) {
+          // Generate redirect HTML
+          await generateRedirectPage(actualPath, staticProps.redirect, outDir, result);
+          continue;
+        }
+        
+        props = { ...props, ...staticProps.props };
+      }
+
+      // Render the page
+      const html = await renderPage({
+        Component,
+        props,
+        title: module.title || module.metadata?.title || 'FlexiReact App',
+        meta: module.metadata || {},
+        isSSG: true
+      });
+
+      // Write to file
+      const filePath = getOutputPath(actualPath, outDir);
+      ensureDir(path.dirname(filePath));
+      fs.writeFileSync(filePath, html);
+
+      const size = Buffer.byteLength(html, 'utf8');
+      result.addPage(actualPath, filePath, size);
+      
+      console.log(`  ✓ ${actualPath} (${formatSize(size)})`);
+
+    } catch (error) {
+      result.addError(actualPath, error);
+      console.error(`  ✗ ${actualPath}: ${error.message}`);
+    }
+  }
+}
+
+/**
+ * Generates a redirect page
+ */
+async function generateRedirectPage(fromPath, redirect, outDir, result) {
+  const { destination, permanent = false } = redirect;
+  const statusCode = permanent ? 301 : 302;
+
+  const html = `<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="utf-8">
+  <meta http-equiv="refresh" content="0;url=${destination}">
+  <link rel="canonical" href="${destination}">
+  <title>Redirecting...</title>
+</head>
+<body>
+  <p>Redirecting to <a href="${destination}">${destination}</a></p>
+  <script>window.location.href = "${destination}";</script>
+</body>
+</html>`;
+
+  const filePath = getOutputPath(fromPath, outDir);
+  ensureDir(path.dirname(filePath));
+  fs.writeFileSync(filePath, html);
+
+  const size = Buffer.byteLength(html, 'utf8');
+  result.addPage(fromPath, filePath, size);
+  
+  console.log(`  ↪ ${fromPath} → ${destination}`);
+}
+
+/**
+ * Substitutes route params into path
+ */
+function substituteParams(routePath, params) {
+  let result = routePath;
+  
+  for (const [key, value] of Object.entries(params)) {
+    result = result.replace(`:${key}`, value);
+    result = result.replace(`*${key}`, value);
+  }
+  
+  return result;
+}
+
+/**
+ * Gets the output file path for a route
+ */
+function getOutputPath(routePath, outDir) {
+  if (routePath === '/') {
+    return path.join(outDir, 'index.html');
+  }
+  
+  // Remove leading slash and add index.html
+  const cleanPath = routePath.replace(/^\//, '');
+  return path.join(outDir, cleanPath, 'index.html');
+}
+
+/**
+ * Formats file size
+ */
+function formatSize(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(2)} MB`;
+}
+
+/**
+ * Incremental Static Regeneration (ISR) support
+ * Allows pages to be regenerated after a specified interval
+ */
+export class ISRManager {
+  constructor(options = {}) {
+    this.cache = new Map();
+    this.revalidating = new Set();
+    this.defaultRevalidate = options.defaultRevalidate || 60; // seconds
+  }
+
+  /**
+   * Gets a cached page or regenerates it
+   */
+  async getPage(routePath, generator) {
+    const cached = this.cache.get(routePath);
+    const now = Date.now();
+
+    if (cached) {
+      // Check if revalidation is needed
+      if (cached.revalidateAfter && now > cached.revalidateAfter) {
+        // Trigger background revalidation
+        this.revalidateInBackground(routePath, generator);
+      }
+      return cached.html;
+    }
+
+    // Generate fresh page
+    const result = await generator();
+    this.cache.set(routePath, {
+      html: result.html,
+      generatedAt: now,
+      revalidateAfter: result.revalidate 
+        ? now + (result.revalidate * 1000)
+        : null
+    });
+
+    return result.html;
+  }
+
+  /**
+   * Revalidates a page in the background
+   */
+  async revalidateInBackground(routePath, generator) {
+    if (this.revalidating.has(routePath)) return;
+
+    this.revalidating.add(routePath);
+
+    try {
+      const result = await generator();
+      const now = Date.now();
+      
+      this.cache.set(routePath, {
+        html: result.html,
+        generatedAt: now,
+        revalidateAfter: result.revalidate 
+          ? now + (result.revalidate * 1000)
+          : null
+      });
+    } catch (error) {
+      console.error(`ISR revalidation failed for ${routePath}:`, error);
+    } finally {
+      this.revalidating.delete(routePath);
+    }
+  }
+
+  /**
+   * Invalidates a cached page
+   */
+  invalidate(routePath) {
+    this.cache.delete(routePath);
+  }
+
+  /**
+   * Clears all cached pages
+   */
+  clear() {
+    this.cache.clear();
+  }
+}
+
+export default {
+  generateStaticSite,
+  SSGResult,
+  ISRManager
+};

package/core/utils.js

@@ -0,0 +1,176 @@
+/**
+ * FlexiReact Utility Functions
+ */
+
+import fs from 'fs';
+import path from 'path';
+import crypto from 'crypto';
+
+/**
+ * Generates a unique hash for cache busting
+ */
+export function generateHash(content) {
+  return crypto.createHash('md5').update(content).digest('hex').slice(0, 8);
+}
+
+/**
+ * Escapes HTML special characters
+ */
+export function escapeHtml(str) {
+  const htmlEntities = {
+    '&': '&',
+    '<': '&lt;',
+    '>': '&gt;',
+    '"': '&quot;',
+    "'": '&#39;'
+  };
+  return String(str).replace(/[&<>"']/g, char => htmlEntities[char]);
+}
+
+/**
+ * Recursively finds all files matching a pattern
+ */
+export function findFiles(dir, pattern, files = []) {
+  if (!fs.existsSync(dir)) return files;
+  
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+  
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+    
+    if (entry.isDirectory()) {
+      findFiles(fullPath, pattern, files);
+    } else if (pattern.test(entry.name)) {
+      files.push(fullPath);
+    }
+  }
+  
+  return files;
+}
+
+/**
+ * Ensures a directory exists
+ */
+export function ensureDir(dir) {
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+}
+
+/**
+ * Cleans a directory
+ */
+export function cleanDir(dir) {
+  if (fs.existsSync(dir)) {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+  fs.mkdirSync(dir, { recursive: true });
+}
+
+/**
+ * Copies a directory recursively
+ */
+export function copyDir(src, dest) {
+  ensureDir(dest);
+  
+  const entries = fs.readdirSync(src, { withFileTypes: true });
+  
+  for (const entry of entries) {
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+    
+    if (entry.isDirectory()) {
+      copyDir(srcPath, destPath);
+    } else {
+      fs.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+
+/**
+ * Debounce function for file watching
+ */
+export function debounce(fn, delay) {
+  let timeout;
+  return (...args) => {
+    clearTimeout(timeout);
+    timeout = setTimeout(() => fn(...args), delay);
+  };
+}
+
+/**
+ * Formats bytes to human readable string
+ */
+export function formatBytes(bytes) {
+  if (bytes === 0) return '0 B';
+  const k = 1024;
+  const sizes = ['B', 'KB', 'MB', 'GB'];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
+}
+
+/**
+ * Formats milliseconds to human readable string
+ */
+export function formatTime(ms) {
+  if (ms < 1000) return `${ms}ms`;
+  return `${(ms / 1000).toFixed(2)}s`;
+}
+
+/**
+ * Creates a deferred promise
+ */
+export function createDeferred() {
+  let resolve, reject;
+  const promise = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  return { promise, resolve, reject };
+}
+
+/**
+ * Sleep utility
+ */
+export function sleep(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+/**
+ * Check if a file is a server component (has 'use server' directive)
+ */
+export function isServerComponent(filePath) {
+  try {
+    const content = fs.readFileSync(filePath, 'utf-8');
+    const firstLine = content.split('\n')[0].trim();
+    return firstLine === "'use server'" || firstLine === '"use server"';
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Check if a file is a client component (has 'use client' directive)
+ */
+export function isClientComponent(filePath) {
+  try {
+    const content = fs.readFileSync(filePath, 'utf-8');
+    const firstLine = content.split('\n')[0].trim();
+    return firstLine === "'use client'" || firstLine === '"use client"';
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Check if a component is an island (has 'use island' directive)
+ */
+export function isIsland(filePath) {
+  try {
+    const content = fs.readFileSync(filePath, 'utf-8');
+    const firstLine = content.split('\n')[0].trim();
+    return firstLine === "'use island'" || firstLine === '"use island"';
+  } catch {
+    return false;
+  }
+}