meno-core 1.0.0

package/lib/server/routes/index.ts

@@ -0,0 +1,104 @@
+/**
+ * Route Registration
+ * Centralized route handling with middleware
+ */
+
+import type { PageService } from '../services/pageService';
+import type { ComponentService } from '../services/componentService';
+import type { CMSService } from '../services/cmsService';
+import type { CMSProvider } from '../../shared/interfaces/contentProvider';
+import { HMR_ROUTE } from '../../shared/constants';
+import { handleCorsPreflight } from '../middleware/cors';
+import { handleRouteError } from '../middleware/errorHandler';
+import { logRequest, logResponseTime } from '../middleware/logger';
+import { handleApiRoutes, type CMSRouteContext } from './api/index';
+import { handlePageRoute } from './pages';
+import { handleStaticRoute } from './static';
+
+export interface RouteContext {
+  pageService: PageService;
+  componentService: ComponentService;
+  cmsService?: CMSService;
+  cmsProvider?: CMSProvider;
+}
+
+/**
+ * Handle all routes with middleware
+ */
+export async function handleRoutes(
+  req: Request,
+  url: URL,
+  server: any,
+  context: RouteContext
+): Promise<Response | undefined> {
+  const startTime = Date.now();
+  const { pageService, componentService, cmsService, cmsProvider } = context;
+
+  // Log request
+  logRequest(req);
+
+  // Handle CORS preflight requests
+  const corsResponse = handleCorsPreflight(req);
+  if (corsResponse) {
+    logResponseTime(startTime, req);
+    return corsResponse;
+  }
+
+  try {
+    // WebSocket upgrade for custom YAML reload notifications
+    if (url.pathname === HMR_ROUTE) {
+      const success = server.upgrade(req);
+      logResponseTime(startTime, req);
+      return success
+        ? undefined
+        : new Response('WebSocket upgrade failed', { status: 500 });
+    }
+
+    // Build CMS context if CMS service and provider are available
+    const cmsContext: CMSRouteContext | undefined =
+      cmsService && cmsProvider
+        ? { cmsService, cmsProvider }
+        : undefined;
+
+    // API Routes
+    const apiResponse = await handleApiRoutes(
+      req,
+      url,
+      pageService,
+      componentService,
+      cmsContext
+    );
+    if (apiResponse) {
+      logResponseTime(startTime, req);
+      return apiResponse;
+    }
+
+    // Static asset directories - serve before page routes
+    if (url.pathname.startsWith('/images/') || url.pathname.startsWith('/videos/') || url.pathname.startsWith('/assets/') || url.pathname.startsWith('/public/') || url.pathname.startsWith('/icons/')) {
+      const response = await handleStaticRoute(url);
+      if (response) {
+        logResponseTime(startTime, req);
+        return response;
+      }
+    }
+
+    // Page routes (SSR)
+    if (url.pathname === '/' || (url.pathname.startsWith('/') && !url.pathname.includes('.'))) {
+      const response = await handlePageRoute(url, context);
+      logResponseTime(startTime, req);
+      return response;
+    }
+
+    // Static files
+    const response = await handleStaticRoute(url);
+    logResponseTime(startTime, req);
+    return response;
+  } catch (error) {
+    logResponseTime(startTime, req);
+    return handleRouteError(
+      () => Promise.reject(error),
+      `Error handling route: ${url.pathname}`
+    );
+  }
+}
+

package/lib/server/routes/pages.ts

@@ -0,0 +1,161 @@
+/**
+ * Page Route Handler
+ * Handles page route requests with SSR, i18n, and CMS support
+ */
+
+import type { RouteContext } from './index';
+import { generateSSRHTML } from '../ssrRenderer';
+import { getStaticFilePath } from '../../shared/pathUtils';
+import { parseJSON, loadI18nConfig } from '../jsonLoader';
+import { packagePaths } from '../projectContext';
+import { parseLocaleFromPath } from '../../shared/i18n';
+import { buildSlugIndex, resolveSlugToPageId } from '../../shared/slugTranslator';
+import type { CMSItem } from '../../shared/types';
+
+/**
+ * Handle page route requests
+ */
+export async function handlePageRoute(
+  url: URL,
+  context: RouteContext
+): Promise<Response | undefined> {
+  const { pageService, componentService, cmsService } = context;
+  const pagePath = url.pathname;
+
+  // Load i18n config for locale extraction
+  const i18nConfig = await loadI18nConfig();
+
+  // Parse locale from URL path (e.g., /pl/o-nas -> locale: 'pl', path: '/o-nas')
+  const { locale, pathWithoutLocale } = parseLocaleFromPath(pagePath, i18nConfig);
+
+  // Build slug index for translation lookup
+  const slugMappings = pageService.getSlugMappings();
+  const slugIndex = buildSlugIndex(slugMappings);
+
+  // 1. Try CMS route match first
+  if (cmsService) {
+    const cmsMatch = await cmsService.matchRoute(pathWithoutLocale);
+
+    if (cmsMatch) {
+      // Load template page content by file path
+      const templatePageContent = await loadPageByFilePath(cmsMatch.pagePath);
+
+      if (templatePageContent) {
+        try {
+          // Parse page JSON
+          const pageData = parseJSON(templatePageContent);
+
+          // Convert global components Map to Record for SSR
+          const globalComponentsRecord = componentService.getAllComponents();
+
+          // Generate SSR HTML with CMS context
+          const baseUrl = `${url.protocol}//${url.host}`;
+          const ssrHTML = await generateSSRHTML(
+            pageData,
+            globalComponentsRecord,
+            pagePath,
+            baseUrl,
+            false,
+            locale,
+            slugMappings,
+            { cms: cmsMatch.item }  // Pass CMS item as context
+          );
+
+          return new Response(ssrHTML, {
+            headers: {
+              'Content-Type': 'text/html; charset=utf-8',
+              'Cache-Control': 'no-store, max-age=0',
+              'Pragma': 'no-cache',
+              'Expires': '0',
+            },
+          });
+        } catch (error) {
+          console.error('Error rendering CMS page:', error);
+          return new Response(Bun.file(packagePaths.indexHtml()));
+        }
+      }
+    }
+  }
+
+  // 2. Fall back to static page routing
+
+  // Extract slug from path (remove leading slash)
+  const slug = pathWithoutLocale === '/' ? '' : pathWithoutLocale.substring(1);
+
+  // Try to resolve translated slug to pageId (e.g., "o-nas" + "pl" -> "about")
+  const pageId = resolveSlugToPageId(slug, locale, slugIndex);
+
+  // Determine lookup path: use resolved pageId or fall back to original path
+  let lookupPath: string;
+  if (pageId) {
+    lookupPath = pageId === 'index' ? '/' : `/${pageId}`;
+  } else {
+    // No translation found, use original path without locale
+    lookupPath = pathWithoutLocale;
+  }
+
+  // Skip static files in development mode - always use fresh SSR from JSON files
+  const isDevelopment = true; // Always true when running dev server
+
+  if (!isDevelopment) {
+    // Production mode: Check for pre-built static file first
+    const staticFilePath = getStaticFilePath(pagePath);
+    const staticFile = Bun.file(staticFilePath);
+
+    if (await staticFile.exists()) {
+      return new Response(staticFile, {
+        headers: {
+          'Content-Type': 'text/html; charset=utf-8',
+          'Cache-Control': 'public, max-age=31536000', // 1 year cache for static files
+        },
+      });
+    }
+  }
+
+  // Development mode: Always use fresh SSR from JSON files (no caching)
+  const pageContent = pageService.getPage(lookupPath);
+
+  if (pageContent) {
+    try {
+      // Parse page JSON
+      const pageData = parseJSON(pageContent);
+
+      // Convert global components Map to Record for SSR
+      const globalComponentsRecord = componentService.getAllComponents();
+
+      // Generate SSR HTML with pre-rendered content and locale
+      const baseUrl = `${url.protocol}//${url.host}`;
+      const ssrHTML = await generateSSRHTML(pageData, globalComponentsRecord, pagePath, baseUrl, false, locale, slugMappings);
+
+      return new Response(ssrHTML, {
+        headers: {
+          'Content-Type': 'text/html; charset=utf-8',
+          'Cache-Control': 'no-store, max-age=0',
+          'Pragma': 'no-cache',
+          'Expires': '0',
+        },
+      });
+    } catch (error) {
+      // Fallback to client-side rendering on error
+      return new Response(Bun.file(packagePaths.indexHtml()));
+    }
+  } else {
+    // Page not found - still return HTML shell for client-side 404 handling
+    return new Response(Bun.file(packagePaths.indexHtml()));
+  }
+}
+
+/**
+ * Load page content by file path (for CMS template pages)
+ */
+async function loadPageByFilePath(filePath: string): Promise<string | null> {
+  try {
+    const file = Bun.file(filePath);
+    if (await file.exists()) {
+      return await file.text();
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}

package/lib/server/routes/static.ts

@@ -0,0 +1,107 @@
+/**
+ * Static File Route Handler
+ * Serves static files and handles TypeScript/TSX file requests
+ */
+
+import { join } from 'path';
+import { resolveProjectPath, resolvePackagePath, packagePaths } from '../projectContext';
+
+export async function handleStaticRoute(url: URL): Promise<Response | undefined> {
+  // Handle client-router requests (both .js and .tsx)
+  if (url.pathname === '/client-router.js' || url.pathname === '/client-router.tsx') {
+    const result = await Bun.build({
+      entrypoints: [packagePaths.clientRouter()],
+      target: 'browser',
+      format: 'esm',
+      minify: false,
+      sourcemap: 'inline',
+    });
+
+    if (result.success && result.outputs[0]) {
+      return new Response(result.outputs[0], {
+        headers: {
+          'Content-Type': 'application/javascript',
+          'Cache-Control': 'no-cache, no-store, must-revalidate',
+        },
+      });
+    }
+  }
+
+  // Serve client bundle with HMR enabled (editor TypeScript files)
+  if (url.pathname.endsWith('.tsx') || url.pathname.endsWith('.ts')) {
+    const entrypoint = resolvePackagePath(url.pathname.slice(1));
+    const result = await Bun.build({
+      entrypoints: [entrypoint],
+      target: 'browser',
+      format: 'esm',
+      minify: false,
+      sourcemap: 'inline',
+    });
+
+    if (result.success && result.outputs[0]) {
+      return new Response(result.outputs[0], {
+        headers: {
+          'Content-Type': 'application/javascript',
+          'Cache-Control': 'no-cache, no-store, must-revalidate',
+        },
+      });
+    }
+  }
+
+  // Serve static files (including fonts and images)
+  const decodedPathname = decodeURIComponent(url.pathname);
+
+  // For fonts, images, and icons, resolve relative to project root
+  // Other static files (editor assets) resolve relative to package root
+  let filePath: string;
+  if (decodedPathname.startsWith('/fonts/') || decodedPathname.startsWith('/images/') || decodedPathname.startsWith('/icons/')) {
+    filePath = resolveProjectPath(decodedPathname.slice(1)); // Remove leading /
+  } else {
+    filePath = resolvePackagePath(decodedPathname.slice(1)); // Remove leading /
+  }
+
+  const file = Bun.file(filePath);
+  if (await file.exists()) {
+    const pathname = decodedPathname.toLowerCase();
+    let contentType = 'application/octet-stream';
+
+    // Set proper MIME types for font files
+    if (pathname.endsWith('.woff2')) {
+      contentType = 'font/woff2';
+    } else if (pathname.endsWith('.woff')) {
+      contentType = 'font/woff';
+    } else if (pathname.endsWith('.ttf')) {
+      contentType = 'font/ttf';
+    } else if (pathname.endsWith('.otf')) {
+      contentType = 'font/otf';
+    }
+    // Set proper MIME types for image files
+    else if (pathname.endsWith('.jpg') || pathname.endsWith('.jpeg')) {
+      contentType = 'image/jpeg';
+    } else if (pathname.endsWith('.png')) {
+      contentType = 'image/png';
+    } else if (pathname.endsWith('.gif')) {
+      contentType = 'image/gif';
+    } else if (pathname.endsWith('.webp')) {
+      contentType = 'image/webp';
+    } else if (pathname.endsWith('.svg')) {
+      contentType = 'image/svg+xml';
+    } else if (pathname.endsWith('.ico')) {
+      contentType = 'image/x-icon';
+    } else if (pathname.endsWith('.bmp')) {
+      contentType = 'image/bmp';
+    } else if (pathname.endsWith('.tiff') || pathname.endsWith('.tif')) {
+      contentType = 'image/tiff';
+    }
+
+    return new Response(file, {
+      headers: {
+        'Content-Type': contentType,
+        'Cache-Control': 'public, max-age=31536000, immutable', // Cache static files for 1 year
+      },
+    });
+  }
+
+  return undefined;
+}
+

package/lib/server/services/ColorService.ts

@@ -0,0 +1,193 @@
+/**
+ * Color Service
+ * Manages loading and caching of color variables and themes from colors.json
+ */
+
+import { loadJSONFile, parseJSON } from '../jsonLoader';
+import { projectPaths } from '../projectContext';
+import type { ColorVariables, ColorVariableEntry, ThemeConfig, ThemeEntry } from '../../shared/types';
+
+export class ColorService {
+  private themeConfig: ThemeConfig | null = null;
+  private loadingPromise: Promise<ThemeConfig> | null = null;
+
+  /**
+   * Load theme configuration from colors.json
+   */
+  async loadThemeConfig(): Promise<ThemeConfig> {
+    // Return cached config if already loaded
+    if (this.themeConfig) {
+      return this.themeConfig;
+    }
+
+    // Return existing loading promise if already in progress
+    if (this.loadingPromise) {
+      return this.loadingPromise;
+    }
+
+    // Start loading
+    this.loadingPromise = this.performLoad();
+    this.themeConfig = await this.loadingPromise;
+    this.loadingPromise = null;
+
+    return this.themeConfig;
+  }
+
+  /**
+   * Perform the actual loading from file
+   */
+  private async performLoad(): Promise<ThemeConfig> {
+    try {
+      const content = await loadJSONFile(projectPaths.colors());
+      if (content) {
+        const data = parseJSON(content);
+        if (data && typeof data === 'object' && 'themes' in data && 'default' in data) {
+          return data as ThemeConfig;
+        }
+      }
+    } catch (error) {
+      console.warn('Failed to load colors.json:', error);
+    }
+
+    // Return default theme config if file not found or invalid
+    return this.getDefaultThemeConfig();
+  }
+
+  /**
+   * Get default theme configuration
+   */
+  private getDefaultThemeConfig(): ThemeConfig {
+    return {
+      default: 'dark',
+      themes: {
+        dark: {
+          label: 'Dark',
+          colors: {
+            'primary': '#007acc',
+            'primary-light': '#0099ff',
+            'primary-dark': '#005a99',
+            'secondary': '#6c757d',
+            'success': '#28a745',
+            'warning': '#ffc107',
+            'danger': '#dc3545',
+            'error': '#d32f2f',
+            'info': '#17a2b8',
+            'light': '#f8f9fa',
+            'dark': '#343a40',
+            'text': '#cccccc',
+            'text-dark': '#1e1e1e',
+            'background': '#1e1e1e',
+            'background-light': '#252526',
+            'border': '#444444',
+            'border-light': '#d0d0d0',
+          },
+        },
+        light: {
+          label: 'Light',
+          colors: {
+            'primary': '#0066ff',
+            'primary-light': '#3385ff',
+            'primary-dark': '#0052cc',
+            'secondary': '#888888',
+            'success': '#22c55e',
+            'warning': '#f59e0b',
+            'danger': '#ef4444',
+            'error': '#dc2626',
+            'info': '#06b6d4',
+            'light': '#f8f9fa',
+            'dark': '#1f2937',
+            'text': '#1f2937',
+            'text-dark': '#ffffff',
+            'background': '#ffffff',
+            'background-light': '#f3f4f6',
+            'border': '#d1d5db',
+            'border-light': '#e5e7eb',
+          },
+        },
+      },
+    };
+  }
+
+  /**
+   * Get colors for a specific theme (or default if not found)
+   */
+  async getThemeColors(themeName?: string): Promise<ColorVariables> {
+    const config = await this.loadThemeConfig();
+    const theme = themeName && config.themes[themeName] ? config.themes[themeName] : config.themes[config.default];
+    return { colors: theme.colors };
+  }
+
+  /**
+   * Load color variables from colors.json (for backward compatibility)
+   */
+  async loadColors(): Promise<ColorVariables> {
+    return this.getThemeColors();
+  }
+
+  /**
+   * Get all available themes
+   */
+  async getAvailableThemes(): Promise<ThemeEntry[]> {
+    const config = await this.loadThemeConfig();
+    return Object.entries(config.themes).map(([name, theme]) => ({
+      name,
+      label: theme.label,
+    }));
+  }
+
+  /**
+   * Get default theme name
+   */
+  async getDefaultTheme(): Promise<string> {
+    const config = await this.loadThemeConfig();
+    return config.default;
+  }
+
+  /**
+   * Get all color variables as entries for a theme
+   */
+  async getColorEntries(themeName?: string): Promise<ColorVariableEntry[]> {
+    const colors = await this.getThemeColors(themeName);
+    return Object.entries(colors.colors).map(([name, value]) => ({
+      name,
+      value,
+    }));
+  }
+
+  /**
+   * Get a specific color by name from a theme
+   */
+  async getColor(name: string, themeName?: string): Promise<string | null> {
+    const colors = await this.getThemeColors(themeName);
+    return colors.colors[name] || null;
+  }
+
+  /**
+   * Clear cache (used for hot reload)
+   */
+  clearCache(): void {
+    this.themeConfig = null;
+  }
+
+  /**
+   * Get the full theme configuration (for editor)
+   */
+  async getFullConfig(): Promise<ThemeConfig> {
+    return this.loadThemeConfig();
+  }
+
+  /**
+   * Save theme configuration to colors.json
+   */
+  async saveThemeConfig(config: ThemeConfig): Promise<void> {
+    const colorsPath = projectPaths.colors();
+    const content = JSON.stringify(config, null, 2);
+    await Bun.write(colorsPath, content);
+
+    // Update cache with new config
+    this.themeConfig = config;
+  }
+}
+
+// Export singleton instance
+export const colorService = new ColorService();