vaderjs 2.3.15 → 2.3.17

package/config/index.ts

@@ -1,6 +1,6 @@
 export type Config = {
-  name: string,
-  version: string,
+  name?: string,
+  version?: string,
   description?: string,
   port: number,
   host?: string, 

package/main.ts

@@ -60,6 +60,159 @@ const TEMP_SRC_DIR = path.join(PROJECT_ROOT, ".vader_temp_src");
 let config: any = {};
 let htmlInjections: string[] = [];
 
+// --- Plugin Support ---
+
+interface Plugin {
+  name: string;
+  version: string;
+  description?: string;
+  onBuildStart?: (api: PluginAPI) => Promise<void> | void;
+  onBuildFinish?: (api: PluginAPI) => Promise<void> | void;
+  onFileChange?: (file: string, api: PluginAPI) => Promise<void> | void;
+}
+
+interface PluginAPI {
+  injectHTML(html: string): void;
+  addWatchPath(path: string): void;
+  config: any;
+  isDev: boolean;
+  distDir: string;
+  srcDir: string;
+  publicDir: string;
+  projectRoot: string;
+}
+
+let plugins: Plugin[] = [];
+
+// Create plugin API helper
+function createPluginAPI(): PluginAPI {
+  return {
+    injectHTML: (html: string) => {
+      htmlInjections.push(html);
+    },
+    addWatchPath: (watchPath: string) => {
+      if (fsSync.existsSync(watchPath)) {
+        watcher.watch(watchPath);
+      }
+    },
+    config: config,
+    isDev: globalThis.isDev,
+    distDir: DIST_DIR,
+    srcDir: SRC_DIR,
+    publicDir: PUBLIC_DIR,
+    projectRoot: PROJECT_ROOT
+  };
+}
+
+// Run plugin hooks
+async function runPluginHook(hookName: 'onBuildStart' | 'onBuildFinish', api: PluginAPI) {
+  for (const plugin of plugins) {
+    if (plugin[hookName]) {
+      try {
+        logger.info(`Running plugin hook: ${plugin.name} - ${hookName}`);
+        await plugin[hookName]!(api);
+      } catch (e) {
+        logger.error(`Error in plugin "${plugin.name}" during ${hookName}:`, e);
+        if (!globalThis.isDev) process.exit(1);
+      }
+    }
+  }
+}
+
+// Load plugins from config
+async function loadPluginsFromConfig() {
+  console.log(config)
+  if (!config.plugins || !Array.isArray(config.plugins)) {
+    logger.info("No plugins defined in config");
+    return;
+  }
+
+  const loadedPlugins: Plugin[] = [];
+  
+  for (const pluginConfig of config.plugins) {
+    try {
+      let plugin;
+      
+      // If plugin is a string, import it
+      if (typeof pluginConfig === 'string') {
+        const pluginPath = path.isAbsolute(pluginConfig) 
+          ? pluginConfig 
+          : path.join(PROJECT_ROOT, pluginConfig);
+        
+        // Check if file exists
+        if (fsSync.existsSync(pluginPath)) {
+          const pluginModule = await import(pluginPath);
+          plugin = pluginModule.default || pluginModule;
+        } else {
+          // Try as npm package
+          plugin = await import(pluginConfig);
+        }
+      } 
+      // If plugin is an object with resolve property
+      else if (typeof pluginConfig === 'object' && pluginConfig.resolve) {
+        const pluginModule = await import(pluginConfig.resolve);
+        plugin = pluginModule.default || pluginModule;
+        
+        // Pass options to plugin if it's a factory function
+        if (typeof plugin === 'function' && pluginConfig.options) {
+          plugin = await plugin(pluginConfig.options);
+        }
+      }
+      // If plugin is already a plugin object
+      else if (typeof pluginConfig === 'object' && pluginConfig.name) {
+        plugin = pluginConfig;
+      }
+      
+      if (plugin && typeof plugin === 'object' && plugin.name) {
+        loadedPlugins.push(plugin);
+        logger.success(`Loaded plugin: ${plugin.name} v${plugin.version || 'unknown'}`);
+      } else {
+        logger.warn(`Invalid plugin: missing name property`);
+      }
+    } catch (e) {
+      logger.error(`Failed to load plugin:`, e);
+    }
+  }
+  
+  plugins = loadedPlugins;
+}
+
+// Also load from plugins directory (backward compatibility)
+async function loadPluginsFromDirectory() {
+  const pluginsDir = path.join(PROJECT_ROOT, "plugins");
+  
+  if (!fsSync.existsSync(pluginsDir)) {
+    return;
+  }
+  
+  const pluginFiles = await fs.readdir(pluginsDir);
+  const loadedPlugins: Plugin[] = [];
+  
+  for (const file of pluginFiles) {
+    if (file.endsWith('.js') || file.endsWith('.ts')) {
+      try {
+        const pluginPath = path.join(pluginsDir, file);
+        const pluginModule = await import(pluginPath);
+        const plugin = pluginModule.default || pluginModule;
+        
+        if (plugin && typeof plugin === 'object' && plugin.name) {
+          // Check if plugin already loaded from config
+          if (!plugins.some(p => p.name === plugin.name)) {
+            loadedPlugins.push(plugin);
+            logger.info(`Loaded plugin from directory: ${plugin.name} v${plugin.version}`);
+          }
+        } else {
+          logger.warn(`Invalid plugin in ${file}: missing name property`);
+        }
+      } catch (e) {
+        logger.error(`Failed to load plugin ${file}:`, e);
+      }
+    }
+  }
+  
+  plugins = [...plugins, ...loadedPlugins];
+}
+
 // --- JSConfig Setup ---
 
 async function ensureJSConfig() {
@@ -142,9 +295,14 @@ const watcher = new FileWatcher();
 
 export async function loadConfig() {
   try {
-    const mod = await import(path.join(PROJECT_ROOT, "vaderjs.config.js"));
-    return mod.default || mod;
-  } catch {
+    const configPath = path.join(PROJECT_ROOT, "vaderjs.config.ts");
+    if (fsSync.existsSync(configPath)) {
+      const mod = await import(configPath);
+      return mod.default || mod;
+    }
+    return {};
+  } catch (error) {
+    logger.warn("Failed to load config, using defaults:", error);
     return {};
   }
 }
@@ -276,6 +434,9 @@ async function buildAppEntrypoints() {
   // First check for root App file (VaderJS standard)
   const appFile = findAppFile();
   
+  // Build HTML with injections from plugins
+  const htmlInjectionsString = htmlInjections.join('\n    ');
+  
   if (appFile) {
     logger.info(`Building App from: ${appFile}`);
     
@@ -295,7 +456,8 @@ async function buildAppEntrypoints() {
 <head>
 <meta charset="UTF-8"/>
 <meta name="viewport" content="width=device-width,initial-scale=1"/>
-<title>Vader App</title>
+<title>${config.title || 'Vader App'}</title>
+${htmlInjectionsString}
 </head>
 <body>
 <div id="app"></div>
@@ -344,7 +506,8 @@ async function buildAppEntrypoints() {
 <head>
 <meta charset="UTF-8"/>
 <meta name="viewport" content="width=device-width,initial-scale=1"/>
-<title>Vader App</title>
+<title>${config.title || 'Vader App'}</title>
+${htmlInjectionsString}
 </head>
 <body>
 <div id="app"></div>
@@ -359,6 +522,21 @@ async function buildAppEntrypoints() {
 async function buildAll(dev = false) {
   const start = performance.now();
 
+  // Reset HTML injections before build
+  htmlInjections = [];
+
+  // Load plugins from config first
+  await loadPluginsFromConfig();
+  
+  // Also load from plugins directory (backward compatibility)
+  await loadPluginsFromDirectory();
+  
+  // Create plugin API
+  const pluginAPI = createPluginAPI();
+  
+  // Run onBuildStart hooks
+  await runPluginHook('onBuildStart', pluginAPI);
+
   // Ensure jsconfig.json exists before building
   await ensureJSConfig();
 
@@ -373,6 +551,9 @@ async function buildAll(dev = false) {
   await timedStep("Copy Public", copyPublicAssets);
   await timedStep("Build App", buildAppEntrypoints);
 
+  // Run onBuildFinish hooks
+  await runPluginHook('onBuildFinish', pluginAPI);
+
   logger.success(
     `Build finished in ${(performance.now() - start).toFixed(1)}ms`
   );
@@ -431,14 +612,42 @@ async function runDevServer() {
   watcher.watch(SRC_DIR);
   watcher.watch(PUBLIC_DIR);
   
+  // Watch config file
+  watcher.watch(path.join(PROJECT_ROOT, "vaderjs.config.js"));
+  
+  // Watch plugins directory
+  const pluginsDir = path.join(PROJECT_ROOT, "plugins");
+  if (fsSync.existsSync(pluginsDir)) {
+    watcher.watch(pluginsDir);
+  }
+  
   // Also watch for root App file
   const rootAppDir = path.dirname(findAppFile() || "");
   if (rootAppDir && rootAppDir !== PROJECT_ROOT) {
     watcher.watch(rootAppDir);
   }
 
-  watcher.onChange(async () => {
+  watcher.onChange(async (file) => {
     logger.info("Changes detected, rebuilding...");
+    
+    // If config or plugin file changed, reload config and plugins
+    if (file.includes('vaderjs.config.js') || file.includes('plugins')) {
+      logger.info("Config or plugin changed, reloading...");
+      config = await loadConfig();
+      htmlInjections = [];
+      plugins = [];
+      await loadPluginsFromConfig();
+      await loadPluginsFromDirectory();
+    }
+    
+    // Run onFileChange hooks for plugins
+    const pluginAPI = createPluginAPI();
+    for (const plugin of plugins) {
+      if (plugin.onFileChange) {
+        await plugin.onFileChange(file, pluginAPI);
+      }
+    }
+    
     await buildAll(true);
 
     for (const c of clients) c.send("reload");

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "vaderjs",
-    "version": "2.3.15",
+    "version": "2.3.17",
     "description": "A simple and powerful JavaScript library for building modern web applications.",
     "bin": {
         "vaderjs": "./main.ts"