bertui 1.1.0 → 1.1.1

package/src/config/defaultConfig.js

@@ -1,16 +1,36 @@
+// bertui/src/config/defaultConfig.js
+// Default configuration used when bertui.config.js is not present
+
 export const defaultConfig = {
+  // Site information (used for sitemap generation)
+  siteName: "BertUI App",
+  baseUrl: "http://localhost:3000", // Default to localhost
+  
+  // HTML Meta Tags (SEO)
   meta: {
-    title: "BertUI App",
-    description: "Built with BertUI - Lightning fast React development",
-    keywords: "react, bun, bertui",
+    title: "BertUI - Lightning Fast React",
+    description: "Build lightning-fast React applications with file-based routing powered by Bun",
+    keywords: "react, bun, bertui, fast, file-based routing",
     author: "Pease Ernest",
-    ogImage: "/og-image.png",
-    themeColor: "#f30606ff",
-    lang: "en"
+    themeColor: "#667eea",
+    lang: "en",
+    
+    // Open Graph for social sharing
+    ogTitle: "BertUI - Lightning Fast React Framework",
+    ogDescription: "Build lightning-fast React apps with zero config",
+    ogImage: "/og-image.png"
   },
+  
+  // App Shell Configuration
   appShell: {
     loading: true,
     loadingText: "Loading...",
     backgroundColor: "#ffffff"
+  },
+  
+  // robots.txt Configuration
+  robots: {
+    disallow: [], // No paths blocked by default
+    crawlDelay: null // No crawl delay by default
   }
 };

package/src/config/loadConfig.js

@@ -1,4 +1,4 @@
-// src/config/loadConfig.js
+// src/config/loadConfig.js - COMPLETE CORRECTED VERSION
 import { join } from 'path';
 import { existsSync } from 'fs';
 import { defaultConfig } from './defaultConfig.js';
@@ -13,6 +13,13 @@ export async function loadConfig(root) {
       const userConfig = await import(configPath);
       logger.success('Loaded bertui.config.js');
       
+      // DEBUG: Show what we loaded
+      logger.info(`📋 Config loaded: ${JSON.stringify({
+        hasSiteName: !!(userConfig.default?.siteName || userConfig.siteName),
+        hasBaseUrl: !!(userConfig.default?.baseUrl || userConfig.baseUrl),
+        hasRobots: !!(userConfig.default?.robots || userConfig.robots)
+      })}`);
+      
       // Merge user config with defaults
       return mergeConfig(defaultConfig, userConfig.default || userConfig);
     } catch (error) {
@@ -26,8 +33,17 @@ export async function loadConfig(root) {
 }
 
 function mergeConfig(defaults, user) {
-  return {
-    meta: { ...defaults.meta, ...(user.meta || {}) },
-    appShell: { ...defaults.appShell, ...(user.appShell || {}) }
-  };
+  // Start with user config (so user values override defaults)
+  const merged = { ...user };
+  
+  // Deep merge for nested objects
+  merged.meta = { ...defaults.meta, ...(user.meta || {}) };
+  merged.appShell = { ...defaults.appShell, ...(user.appShell || {}) };
+  merged.robots = { ...defaults.robots, ...(user.robots || {}) };
+  
+  // Ensure we have required top-level fields
+  if (!merged.siteName) merged.siteName = defaults.siteName;
+  if (!merged.baseUrl) merged.baseUrl = defaults.baseUrl;
+  
+  return merged;
 }

package/src/utils/meta-extractor.js

@@ -0,0 +1,61 @@
+// bertui/src/utils/meta-extractor.js
+export function extractMetaFromSource(code) {
+  try {
+    if (!code.includes('export const meta')) {
+      return null;
+    }
+    
+    const metaStart = code.indexOf('export const meta = {');
+    if (metaStart === -1) return null;
+    
+    let braceCount = 0;
+    let inString = false;
+    let stringChar = '';
+    let metaEnd = -1;
+    
+    for (let i = metaStart + 'export const meta = {'.length; i < code.length; i++) {
+      const char = code[i];
+      const prevChar = i > 0 ? code[i - 1] : '';
+      
+      if (!inString && (char === '"' || char === "'" || char === '`')) {
+        inString = true;
+        stringChar = char;
+      } else if (inString && char === stringChar && prevChar !== '\\') {
+        inString = false;
+      }
+      
+      if (!inString) {
+        if (char === '{') braceCount++;
+        if (char === '}') {
+          if (braceCount === 0) {
+            metaEnd = i;
+            break;
+          }
+          braceCount--;
+        }
+      }
+    }
+    
+    if (metaEnd === -1) return null;
+    
+    const metaString = code.substring(metaStart + 'export const meta = {'.length - 1, metaEnd + 1);
+    const meta = {};
+    const pairs = metaString.match(/(\w+)\s*:\s*(['"`][^'"`]*['"`])/g) || [];
+    
+    pairs.forEach(pair => {
+      const colonIndex = pair.indexOf(':');
+      if (colonIndex === -1) return;
+      
+      const key = pair.substring(0, colonIndex).trim();
+      const value = pair.substring(colonIndex + 1).trim().slice(1, -1);
+      
+      if (key && value) {
+        meta[key] = value;
+      }
+    });
+    
+    return Object.keys(meta).length > 0 ? meta : null;
+  } catch (error) {
+    return null;
+  }
+}

package/types/config.d.ts

@@ -0,0 +1,80 @@
+// bertui/types/config.d.ts
+declare module 'bertui/config' {
+  /**
+   * BertUI Configuration
+   */
+  export interface BertuiConfig {
+    /** Site name for SEO */
+    siteName?: string;
+    
+    /** Base URL for sitemap generation (e.g., "https://example.com") */
+    baseUrl?: string;
+    
+    /** HTML meta tags configuration */
+    meta?: {
+      /** Page title */
+      title?: string;
+      /** Meta description */
+      description?: string;
+      /** Meta keywords */
+      keywords?: string;
+      /** Author name */
+      author?: string;
+      /** Open Graph image URL */
+      ogImage?: string;
+      /** Open Graph title */
+      ogTitle?: string;
+      /** Open Graph description */
+      ogDescription?: string;
+      /** Theme color */
+      themeColor?: string;
+      /** Language code (e.g., "en") */
+      lang?: string;
+    };
+    
+    /** App shell configuration */
+    appShell?: {
+      /** Show loading indicator */
+      loading?: boolean;
+      /** Loading text */
+      loadingText?: string;
+      /** Background color */
+      backgroundColor?: string;
+    };
+    
+    /** robots.txt configuration */
+    robots?: {
+      /** Paths to disallow in robots.txt */
+      disallow?: string[];
+      /** Crawl delay in seconds */
+      crawlDelay?: number;
+    };
+  }
+
+  /**
+   * Page meta configuration (exported from page files)
+   */
+  export interface PageMeta {
+    title?: string;
+    description?: string;
+    keywords?: string;
+    author?: string;
+    ogTitle?: string;
+    ogDescription?: string;
+    ogImage?: string;
+    themeColor?: string;
+    lang?: string;
+    publishedDate?: string;
+    updatedDate?: string;
+  }
+
+  /**
+   * Default BertUI configuration
+   */
+  export const defaultConfig: BertuiConfig;
+
+  /**
+   * Load BertUI configuration from bertui.config.js
+   */
+  export function loadConfig(root: string): Promise<BertuiConfig>;
+}

package/types/index.d.ts

@@ -0,0 +1,116 @@
+// bertui/types/index.d.ts
+
+declare namespace React {
+  type ReactNode = any;
+}
+
+declare global {
+  namespace JSX {
+    type Element = any;
+    interface IntrinsicElements {
+      [elemName: string]: any;
+    }
+  }
+}
+declare module 'bertui' {
+  import { BertuiConfig } from 'bertui/config';
+  
+  /**
+   * Logger utility
+   */
+  export interface Logger {
+    info(message: string): void;
+    success(message: string): void;
+    warn(message: string): void;
+    error(message: string): void;
+    debug(message: string): void;
+    bigLog(message: string, options?: { color?: string }): void;
+    table(data: any[]): void;
+  }
+
+  /**
+   * Build options
+   */
+  export interface BuildOptions {
+    /** Project root directory */
+    root?: string;
+  }
+
+  /**
+   * Dev server options
+   */
+  export interface DevOptions {
+    /** Server port */
+    port?: number;
+    /** Project root directory */
+    root?: string;
+  }
+
+  /**
+   * Compile options
+   */
+  export interface CompileOptions {
+    /** Project root directory */
+    root?: string;
+  }
+
+  /**
+   * Logger instance
+   */
+  export const logger: Logger;
+
+  /**
+   * Default configuration
+   */
+  export const defaultConfig: BertuiConfig;
+
+  /**
+   * Load configuration
+   */
+  export function loadConfig(root: string): Promise<BertuiConfig>;
+
+  /**
+   * Start development server
+   */
+  export function startDev(options?: DevOptions): Promise<void>;
+
+  /**
+   * Build for production
+   */
+  export function buildProduction(options?: BuildOptions): Promise<void>;
+
+  /**
+   * Compile project
+   */
+  export function compileProject(root: string): Promise<{
+    outDir: string;
+    stats: { files: number; skipped: number };
+    routes: any[];
+  }>;
+
+  /**
+   * CLI program
+   */
+  export function program(): void;
+
+  /**
+   * BertUI version
+   */
+  export const version: string;
+}
+
+// Global declarations for Server Islands
+declare global {
+  /**
+   * Mark a page component as a Server Island (SSG)
+   * Add this export to any page to enable static generation:
+   * 
+   * @example
+   * ```tsx
+   * export const render = "server";
+   * ```
+   */
+  export const render: "server" | "client";
+}
+
+export {};

package/types/react.d.ts

@@ -0,0 +1,13 @@
+// bertui/types/react.d.ts
+import React from 'react';
+
+declare global {
+  namespace JSX {
+    interface IntrinsicElements {
+      [elemName: string]: React.DetailedHTMLProps<
+        React.HTMLAttributes<HTMLElement>, 
+        HTMLElement
+      >;
+    }
+  }
+}

package/types/router.d.ts

@@ -0,0 +1,79 @@
+// bertui/types/router.d.ts
+declare module 'bertui/router' {
+  import { ReactNode, ComponentType } from 'react';
+
+  /**
+   * Route parameter object
+   */
+  export interface RouteParams {
+    [key: string]: string;
+  }
+
+  /**
+   * Router context value
+   */
+  export interface RouterContext {
+    /** Current active route */
+    currentRoute: Route | null;
+    /** Dynamic route parameters */
+    params: RouteParams;
+    /** Navigate to a new path */
+    navigate: (path: string) => void;
+    /** Current pathname */
+    pathname: string;
+    /** Whether running in SSR mode */
+    isSSR?: boolean;
+  }
+
+  /**
+   * Route configuration object
+   */
+  export interface Route {
+    /** Route path (e.g., "/", "/blog", "/user/:id") */
+    path: string;
+    /** React component to render */
+    component: ComponentType<{ params?: RouteParams }>;
+    /** Route type: "static" or "dynamic" */
+    type: 'static' | 'dynamic';
+  }
+
+  /**
+   * Router component props
+   */
+  export interface RouterProps {
+    /** Array of route configurations */
+    routes: Route[];
+    /** Initial path for SSR */
+    initialPath?: string;
+  }
+
+  /**
+   * Link component props
+   */
+  export interface LinkProps extends React.AnchorHTMLAttributes<HTMLAnchorElement> {
+    /** Destination path */
+    to: string;
+    /** Link content */
+    children: ReactNode;
+  }
+
+  /**
+   * Router component for client-side routing
+   */
+  export const Router: ComponentType<RouterProps>;
+
+  /**
+   * Link component for navigation
+   */
+  export const Link: ComponentType<LinkProps>;
+
+  /**
+   * Hook to access router context
+   */
+  export function useRouter(): RouterContext;
+
+  /**
+   * Exported routes configuration
+   */
+  export const routes: Route[];
+}