@flexireact/core 3.0.1 → 3.0.2

package/core/server.ts

@@ -1,203 +0,0 @@
-#!/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
- */
-interface ServerOptions {
-  port?: number;
-  host?: string;
-  pagesDir?: string;
-}
-
-export function createServer(options: ServerOptions = {}) {
-  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 as number, host as string, () => {
-    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.ts

@@ -1,346 +0,0 @@
-/**
- * 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
- */
-interface SSGPage {
-  path: string;
-  file: string;
-  size: number;
-}
-
-interface SSGError {
-  path: string;
-  error: string;
-}
-
-export class SSGResult {
-  pages: SSGPage[];
-  errors: SSGError[];
-  duration: number;
-
-  constructor() {
-    this.pages = [];
-    this.errors = [];
-    this.duration = 0;
-  }
-
-  addPage(pagePath: string, file: string, size: number) {
-    this.pages.push({ path: pagePath, file, size });
-  }
-
-  addError(pagePath: string, error: Error) {
-    this.errors.push({ path: pagePath, 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
- */
-interface ISRCacheEntry {
-  html: string;
-  generatedAt: number;
-  revalidateAfter: number | null;
-}
-
-export class ISRManager {
-  cache: Map<string, ISRCacheEntry>;
-  revalidating: Set<string>;
-  defaultRevalidate: number;
-
-  constructor(options: { defaultRevalidate?: number } = {}) {
-    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/start-dev.ts

@@ -1,6 +0,0 @@
-/**
- * Development server starter
- */
-import { createServer } from './server/index.js';
-
-createServer({ mode: 'development' });

package/core/start-prod.ts

@@ -1,6 +0,0 @@
-/**
- * Production server starter
- */
-import { createServer } from './server/index.js';
-
-createServer({ mode: 'production' });

package/core/tsconfig.json

@@ -1,30 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "NodeNext",
-    "moduleResolution": "NodeNext",
-    "lib": ["ES2022", "DOM", "DOM.Iterable"],
-    "jsx": "react-jsx",
-    "outDir": "./dist",
-    "rootDir": ".",
-    "strict": false,
-    "noImplicitAny": false,
-    "strictPropertyInitialization": false,
-    "useUnknownInCatchVariables": false,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-    "resolveJsonModule": true,
-    "declaration": false,
-    "sourceMap": true,
-    "allowJs": true,
-    "checkJs": false,
-    "noEmit": true
-  },
-  "include": [
-    "*.ts",
-    "**/*.ts",
-    "**/*.tsx"
-  ],
-  "exclude": ["node_modules", "dist"]
-}