@flexireact/core 3.0.1 → 3.0.2

package/core/router.ts

@@ -1,141 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-
-/**
- * Scans the pages directory and builds a route map
- * @param {string} pagesDir - Path to the pages directory
- * @returns {Object} Route map with paths and file locations
- */
-export function buildRoutes(pagesDir) {
-  const routes = {
-    pages: [],
-    api: []
-  };
-
-  if (!fs.existsSync(pagesDir)) {
-    return routes;
-  }
-
-  scanDirectory(pagesDir, pagesDir, routes);
-  return routes;
-}
-
-/**
- * Recursively scans a directory for route files
- */
-function scanDirectory(baseDir, currentDir, routes) {
-  const entries = fs.readdirSync(currentDir, { withFileTypes: true });
-
-  for (const entry of entries) {
-    const fullPath = path.join(currentDir, entry.name);
-    const relativePath = path.relative(baseDir, fullPath);
-
-    if (entry.isDirectory()) {
-      scanDirectory(baseDir, fullPath, routes);
-    } else if (entry.isFile()) {
-      const ext = path.extname(entry.name);
-      
-      if (ext === '.jsx' || ext === '.js') {
-        const routePath = filePathToRoute(relativePath);
-        const isApi = relativePath.startsWith('api' + path.sep) || relativePath.startsWith('api/');
-
-        if (isApi && ext === '.js') {
-          routes.api.push({
-            path: routePath,
-            filePath: fullPath,
-            pattern: createRoutePattern(routePath)
-          });
-        } else if (!isApi && ext === '.jsx') {
-          routes.pages.push({
-            path: routePath,
-            filePath: fullPath,
-            pattern: createRoutePattern(routePath)
-          });
-        }
-      }
-    }
-  }
-}
-
-/**
- * Converts a file path to a route path
- * pages/index.jsx -> /
- * pages/about.jsx -> /about
- * pages/blog/[id].jsx -> /blog/:id
- * pages/api/hello.js -> /api/hello
- */
-function filePathToRoute(filePath) {
-  // Normalize path separators
-  let route = filePath.replace(/\\/g, '/');
-  
-  // Remove extension
-  route = route.replace(/\.(jsx|js)$/, '');
-  
-  // Convert [param] to :param
-  route = route.replace(/\[([^\]]+)\]/g, ':$1');
-  
-  // Handle index files
-  if (route.endsWith('/index')) {
-    route = route.slice(0, -6) || '/';
-  } else if (route === 'index') {
-    route = '/';
-  }
-  
-  // Ensure leading slash
-  if (!route.startsWith('/')) {
-    route = '/' + route;
-  }
-  
-  return route;
-}
-
-/**
- * Creates a regex pattern for route matching
- */
-function createRoutePattern(routePath) {
-  const pattern = routePath
-    .replace(/:[^/]+/g, '([^/]+)')
-    .replace(/\//g, '\\/');
-  
-  return new RegExp(`^${pattern}$`);
-}
-
-/**
- * Matches a URL path against the route map
- * @param {string} urlPath - The URL path to match
- * @param {Array} routes - Array of route objects
- * @returns {Object|null} Matched route with params or null
- */
-export function matchRoute(urlPath, routes) {
-  // Normalize the URL path
-  const normalizedPath = urlPath === '' ? '/' : urlPath;
-  
-  for (const route of routes) {
-    const match = normalizedPath.match(route.pattern);
-    
-    if (match) {
-      // Extract params from the match
-      const params = {};
-      const paramNames = (route.path.match(/:[^/]+/g) || []).map(p => p.slice(1));
-      
-      paramNames.forEach((name, index) => {
-        params[name] = match[index + 1];
-      });
-      
-      return {
-        ...route,
-        params
-      };
-    }
-  }
-  
-  return null;
-}
-
-/**
- * Invalidates the module cache for hot reload
- */
-export function invalidateCache(filePath) {
-  // For ESM, we use query string cache busting
-  return `${filePath}?t=${Date.now()}`;
-}

package/core/rsc/index.ts

@@ -1,199 +0,0 @@
-/**
- * FlexiReact React Server Components (RSC) System
- * 
- * RSC allows components to run exclusively on the server, reducing client bundle size
- * and enabling direct database/filesystem access in components.
- * 
- * Usage:
- * - Add 'use server' at the top of a component file to make it a Server Component
- * - Add 'use client' at the top to make it a Client Component (hydrated on client)
- * - Server Components can import Client Components, but not vice versa
- */
-
-import React from 'react';
-import { renderToString } from 'react-dom/server';
-import { isServerComponent, isClientComponent } from '../utils.js';
-
-/**
- * RSC Payload format for streaming
- */
-export const RSC_CONTENT_TYPE = 'text/x-component';
-
-/**
- * Processes a component tree for RSC
- * Server components are rendered to HTML, client components are serialized
- */
-export async function processServerComponent(Component, props, context) {
-  const componentInfo = {
-    isServer: true,
-    rendered: null,
-    clientComponents: [],
-    serverData: {}
-  };
-
-  try {
-    // If component has async data fetching
-    if (Component.getServerData) {
-      componentInfo.serverData = await Component.getServerData(context);
-      props = { ...props, ...componentInfo.serverData };
-    }
-
-    // Render the server component
-    const element = React.createElement(Component, props);
-    componentInfo.rendered = renderToString(element);
-
-  } catch (error) {
-    console.error('RSC Error:', error);
-    throw error;
-  }
-
-  return componentInfo;
-}
-
-/**
- * Creates a client component reference for RSC payload
- */
-export function createClientReference(componentPath, props) {
-  return {
-    $$typeof: Symbol.for('react.client.reference'),
-    $$id: componentPath,
-    $$props: props
-  };
-}
-
-/**
- * Serializes RSC payload for streaming
- */
-export function serializeRSCPayload(componentTree) {
-  const payload = {
-    type: 'rsc',
-    tree: serializeNode(componentTree),
-    timestamp: Date.now()
-  };
-
-  return JSON.stringify(payload);
-}
-
-/**
- * Serializes a React node for RSC
- */
-function serializeNode(node) {
-  if (node === null || node === undefined) {
-    return null;
-  }
-
-  if (typeof node === 'string' || typeof node === 'number' || typeof node === 'boolean') {
-    return node;
-  }
-
-  if (Array.isArray(node)) {
-    return node.map(serializeNode);
-  }
-
-  if (React.isValidElement(node)) {
-    const { type, props } = node;
-
-    // Handle client component references
-    const typeAny = type as any;
-    if (typeAny.$$typeof === Symbol.for('react.client.reference')) {
-      return {
-        $$type: 'client',
-        $$id: typeAny.$$id,
-        props: serializeProps(props)
-      };
-    }
-
-    // Handle regular elements
-    const typeName = typeof type === 'string' ? type : (typeAny.displayName || typeAny.name || 'Unknown');
-
-    return {
-      $$type: 'element',
-      type: typeName,
-      props: serializeProps(props)
-    };
-  }
-
-  return String(node);
-}
-
-/**
- * Serializes props, handling special cases
- */
-function serializeProps(props: Record<string, any>) {
-  const serialized: Record<string, any> = {};
-
-  for (const [key, value] of Object.entries(props)) {
-    if (key === 'children') {
-      serialized.children = serializeNode(value);
-    } else if (typeof value === 'function') {
-      // Functions can't be serialized - mark as client action
-      serialized[key] = { $$type: 'action', name: value.name };
-    } else if (value instanceof Date) {
-      serialized[key] = { $$type: 'date', value: value.toISOString() };
-    } else if (typeof value === 'object' && value !== null) {
-      serialized[key] = JSON.parse(JSON.stringify(value));
-    } else {
-      serialized[key] = value;
-    }
-  }
-
-  return serialized;
-}
-
-/**
- * Server Actions support
- * Allows calling server functions from client components
- */
-export function createServerAction(fn, actionId) {
-  // Mark function as server action
-  fn.$$typeof = Symbol.for('react.server.action');
-  fn.$$id = actionId;
-  
-  return fn;
-}
-
-/**
- * Handles server action invocation
- */
-export async function handleServerAction(actionId, args, context) {
-  // Actions are registered during build
-  const action = globalThis.__FLEXI_ACTIONS__?.[actionId];
-  
-  if (!action) {
-    throw new Error(`Server action not found: ${actionId}`);
-  }
-
-  return await action(...args, context);
-}
-
-/**
- * RSC Boundary component
- * Marks the boundary between server and client rendering
- */
-export function ServerBoundary({ children, fallback }) {
-  return children;
-}
-
-/**
- * Client Boundary component
- * Marks components that should be hydrated on the client
- */
-export function ClientBoundary({ children, fallback }) {
-  // On server, render children normally
-  // On client, this will be hydrated
-  return React.createElement('div', {
-    'data-flexi-client': 'true',
-    children
-  });
-}
-
-export default {
-  processServerComponent,
-  createClientReference,
-  serializeRSCPayload,
-  createServerAction,
-  handleServerAction,
-  ServerBoundary,
-  ClientBoundary,
-  RSC_CONTENT_TYPE
-};