zuby 1.0.42 → 1.0.44

package/commands/build.js

@@ -1,36 +1,35 @@
-import { MODES } from '../types.js';
-import { getZubyInternalConfig } from '../config.js';
+import { MODES, PLUGIN_HOOKS } from '../types.js';
+import { executePlugins, getZubyInternalConfig } from '../config.js';
 import chalk from 'chalk';
 import { getTitle } from '../branding.js';
 import { build as viteBuild } from 'vite';
-import { dirname, join } from 'path';
+import { dirname, join, resolve } from 'path';
 import { normalizePath } from '../utils/pathUtils.js';
-import { existsSync, rmSync, writeFileSync, copyFileSync, mkdirSync } from 'fs';
+import { existsSync, rmSync, writeFileSync, copyFileSync, readFileSync, } from 'fs';
 import { TEMPLATES } from '../templates/types.js';
 import { glob } from 'glob';
 import { fileURLToPath } from 'url';
 import { getZubyPackageConfig } from '../packageConfig.js';
-import { nodeFileTrace } from '@vercel/nft';
-import { copyFile } from 'fs/promises';
+import { getTemplates } from '../templates/index.js';
+import { CLIENT_CHUNKS_MANIFEST, SERVER_CHUNKS_MANIFEST } from '../constants.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 export default async function build(options) {
     const zubyInternalConfig = await getZubyInternalConfig(options.configFile);
-    const { vite: viteConfig, customLogger: logger, outDir, srcDir, cacheDir, publicDir, configFilePath, } = zubyInternalConfig;
+    const { vite: viteConfig, customLogger: logger, outDir, cacheDir, plugins } = zubyInternalConfig;
+    let buildStep = 1;
+    const buildSteps = 2 + plugins.filter(plugin => plugin?.buildStep).length;
+    const nextBuildStep = (description) => {
+        logger?.info(`${chalk.bgYellow.bold.whiteBright(` Step ${buildStep++}/${buildSteps} `)} ${chalk.gray(description)}`);
+    };
     process.env.NODE_ENV = MODES.production;
     logger?.info(getTitle(chalk.gray(`building for production...`)));
-    // Clean build directory
-    if (existsSync(outDir || '')) {
-        rmSync(outDir || '', {
-            recursive: true,
-        });
-    }
+    // Load templates from the project directory
+    const templates = await getTemplates();
     // Load the entry file from the project directory
     // or jsxProvider
     const entryFile = await getEntryFile(zubyInternalConfig);
-    // Client build
-    logger?.info(`${chalk.bgYellow.bold.whiteBright(` Step 1/4 `)} ${chalk.gray(`building client...`)}`);
-    await viteBuild({
+    const clientViteBuildConfig = {
         configFile: false,
         ...viteConfig,
         build: {
@@ -45,10 +44,8 @@ export default async function build(options) {
         },
         cacheDir: normalizePath(join(cacheDir, 'client')),
         mode: MODES.production,
-    });
-    // Server build
-    logger?.info(`${chalk.bgYellow.bold.whiteBright(` Step 2/4 `)} ${chalk.gray(`building server...`)}`);
-    await viteBuild({
+    };
+    const serverViteBuildConfig = {
         ...viteConfig,
         configFile: false,
         publicDir: false,
@@ -60,6 +57,36 @@ export default async function build(options) {
         },
         cacheDir: normalizePath(join(cacheDir, 'server')),
         mode: MODES.production,
+    };
+    // Run build setup hook
+    await executePlugins(zubyInternalConfig, PLUGIN_HOOKS.ZubyBuildSetup, {
+        clientViteBuildConfig,
+        serverViteBuildConfig,
+        templates,
+    });
+    // Run build start hook
+    await executePlugins(zubyInternalConfig, PLUGIN_HOOKS.ZubyBuildStart, {
+        templates,
+    });
+    // Clean build directory
+    if (existsSync(outDir || '')) {
+        rmSync(outDir || '', {
+            recursive: true,
+        });
+    }
+    // Client build
+    nextBuildStep('building client...');
+    await viteBuild(clientViteBuildConfig);
+    // Run build client done hook
+    await executePlugins(zubyInternalConfig, PLUGIN_HOOKS.ZubyBuildClientDone, {
+        templates,
+    });
+    // Server build
+    nextBuildStep('building server...');
+    await viteBuild(serverViteBuildConfig);
+    // Run build server done hook
+    await executePlugins(zubyInternalConfig, PLUGIN_HOOKS.ZubyBuildServerDone, {
+        templates,
     });
     // Add serialized zuby config to build directory
     writeFileSync(normalizePath(join(outDir, 'zuby.config.json')), JSON.stringify(zubyInternalConfig, null, 2));
@@ -72,30 +99,29 @@ export default async function build(options) {
         name,
         version,
     }));
-    logger?.info(`${chalk.bgYellow.bold.whiteBright(` Step 4/4 `)} ${chalk.gray(`tracing dependencies...`)}`);
-    logger?.info(`Tracing production dependencies...`);
-    const serverFiles = await glob(`${normalizePath(outDir)}/server/**/*.js`);
-    const { fileList } = await nodeFileTrace(serverFiles, {
-        processCwd: process.cwd(),
-        ignore: (path) => {
-            return path.startsWith(outDir);
-        },
-    });
-    logger?.info(`Copying ${fileList.size} files...`);
-    const copyFilePromises = [...fileList].map(async (srcFile) => {
-        const destFile = normalizePath(join(outDir, srcFile));
-        const destDir = dirname(destFile);
-        if (srcFile.startsWith(outDir) || existsSync(destFile)) {
+    // Load the chunks manifest files
+    const clientChunksManifestPath = resolve(outDir, CLIENT_CHUNKS_MANIFEST);
+    const serverChunksManifestPath = resolve(outDir, SERVER_CHUNKS_MANIFEST);
+    const clientChunksManifest = existsSync(clientChunksManifestPath)
+        ? JSON.parse(readFileSync(clientChunksManifestPath, 'utf-8'))
+        : {};
+    const serverChunksManifest = existsSync(serverChunksManifestPath)
+        ? JSON.parse(readFileSync(serverChunksManifestPath, 'utf-8'))
+        : {};
+    // Run build done hook
+    // to execute plugins that are part of the build process
+    await executePlugins(zubyInternalConfig, PLUGIN_HOOKS.ZubyBuildDone, {
+        templates,
+        clientChunksManifest,
+        serverChunksManifest,
+    }, zubyPlugin => {
+        // Hide plugins that are not part of the build process
+        // from the CLI output to avoid confusion
+        if (!zubyPlugin.buildStep)
             return;
-        }
-        if (!existsSync(destDir)) {
-            mkdirSync(destDir, {
-                recursive: true,
-            });
-        }
-        return copyFile(srcFile, destFile);
+        // Increment build step with plugin description
+        nextBuildStep(zubyPlugin.description || zubyPlugin.name);
     });
-    await Promise.all(copyFilePromises);
     logger?.info(`Done! 🎉`);
 }
 export async function getEntryFile(zubyInternalConfig) {

package/commands/dev.js

@@ -1,15 +1,24 @@
-import { getZubyInternalConfig } from '../config.js';
+import { PLUGIN_HOOKS } from '../types.js';
+import { executePlugins, getZubyInternalConfig } from '../config.js';
 import { performance } from 'node:perf_hooks';
 import { getTitle } from '../branding.js';
 import chalk from 'chalk';
 import ZubyDevServer from '../server/zubyDevServer.js';
 export default async function dev(options) {
-    const zubyConfig = await getZubyInternalConfig(options.configFile);
-    const { customLogger: logger } = zubyConfig;
+    const zubyInternalConfig = await getZubyInternalConfig(options.configFile);
+    const { customLogger: logger, server } = zubyInternalConfig;
     const startTime = performance.now();
-    const { host = '127.0.0.1', port = 3000 } = zubyConfig.server;
-    const zubyDevServer = new ZubyDevServer(zubyConfig);
+    const { host = '127.0.0.1', port = 3000 } = server;
+    const zubyDevServer = new ZubyDevServer(zubyInternalConfig);
+    // Run dev setup hook
+    await executePlugins(zubyInternalConfig, PLUGIN_HOOKS.ZubyDevSetup, {
+        devServer: zubyDevServer,
+    });
     await zubyDevServer.listen();
+    // Run dev start hook
+    await executePlugins(zubyInternalConfig, PLUGIN_HOOKS.ZubyDevStart, {
+        devServer: zubyDevServer,
+    });
     const readyTime = performance.now();
     logger?.info(`  ${getTitle(chalk.gray(`started in ${Math.round(readyTime - startTime)}ms`))}\r\n`);
     logger?.info(`  ┃ Mode     development`);

package/config.d.ts

@@ -1,4 +1,5 @@
-import { ZubyConfig, ZubyInternalConfig } from './types.js';
+import { PluginHook, ZubyConfig, ZubyHookParams, ZubyInternalConfig, ZubyPlugin } from './types.js';
+import type { PluginOption as VitePluginOption, Plugin as VitePlugin } from 'vite';
 /**
  * Returns the path to the ZubyConfig file.
  */
@@ -26,8 +27,24 @@ export declare const validateConfig: (config: ZubyConfig) => void;
  */
 export declare const mergeDefaultConfig: (config: ZubyConfig) => Promise<ZubyInternalConfig>;
 /**
- * This function returns the array of built-in Zuby plugins.
+ * This function returns the array of built-in plugins.
  * Check which framework components are relying on each plugin
  * before removing any of them.
  */
-export declare const getBuiltInPlugins: () => (false | import("vite").Plugin<any> | import("vite").PluginOption[] | Promise<false | import("vite").Plugin<any> | import("vite").PluginOption[] | null | undefined> | null | undefined)[];
+export declare const getBuiltInPlugins: () => VitePlugin<any>[];
+/**
+ * Executes the Zuby plugins for the given hook.
+ * @param config The ZubyConfig or ZubyInternalConfig object.
+ * @param hookName The name of the hook to execute.
+ * @param params Additional params to pass to the plugins.
+ * @param beforeHook Callback function to execute before each plugin hook.
+ * @param afterHook Callback function to execute after each plugin hook.
+ * @example executePlugins(config, 'zuby:config:setup', { config, logger })
+ */
+export declare const executePlugins: (config: ZubyConfig | ZubyInternalConfig, hookName: PluginHook, params?: ExecutePluginsParams, beforeHook?: (plugin: ZubyPlugin) => void | Promise<void>, afterHook?: (plugin: ZubyPlugin, hookResult: any) => void | Promise<void>) => Promise<void>;
+export type ExecutePluginsParams = Omit<ZubyHookParams, 'command' | 'logger' | 'config'>;
+/**
+ * Normalizes the plugins to common array format.
+ * @param plugins
+ */
+export declare const normalizePlugins: (plugins: (ZubyPlugin | ZubyPlugin[] | VitePluginOption | VitePluginOption[])[]) => Promise<(ZubyPlugin | VitePlugin)[]>;

package/config.js

@@ -1,3 +1,4 @@
+import { PLUGIN_HOOKS, } from './types.js';
 import { BUILD_CHUNKS_MANIFEST, ZUBY_CONFIG_FILE } from './constants.js';
 import { existsSync } from 'fs';
 import { bundleRequire } from 'bundle-require';
@@ -6,8 +7,9 @@ import { createLogger } from './logger/index.js';
 import contextPlugin from './plugins/contextPlugin/index.js';
 import compileTimePlugin from './plugins/compileTimePlugin/index.js';
 import chunkNamingPlugin from './plugins/chunkNamingPlugin/index.js';
-import prerenderPlugin from './plugins/prerenderPlugin/index.js';
 import manifestPlugin from './plugins/manifestPlugin/index.js';
+import prerenderPlugin from './plugins/prerenderPlugin/index.js';
+import standaloneBuildPlugin from './plugins/dependenciesPlugin/index.js';
 let zubyInternalConfig;
 /**
  * Returns the path to the ZubyConfig file.
@@ -33,8 +35,9 @@ export const getZubyConfig = async (configFilePath) => {
     const { mod } = await bundleRequire({
         filepath: configFilePath,
     });
-    // Find the default export and cache the config
-    const zubyConfig = mod.default || mod;
+    // Find the default export
+    // and wait for it to resolve if it's a promise
+    const zubyConfig = await Promise.resolve(mod.default || mod);
     if (!zubyConfig) {
         throw new Error(`No valid default export found in ZubyConfig file: ${configFilePath}`);
     }
@@ -52,8 +55,12 @@ export const getZubyInternalConfig = async (configFilePath, cache = true) => {
         return zubyInternalConfig;
     const zubyConfig = await getZubyConfig(configFilePath);
     zubyConfig.configFilePath = configFilePath;
+    // Run config setup hook
+    await executePlugins(zubyConfig, PLUGIN_HOOKS.ZubyConfigSetup);
     validateConfig(zubyConfig);
     zubyInternalConfig = await mergeDefaultConfig(zubyConfig);
+    // Run config done hook
+    await executePlugins(zubyInternalConfig, PLUGIN_HOOKS.ZubyConfigDone);
     return zubyInternalConfig;
 };
 /**
@@ -82,6 +89,11 @@ export const mergeDefaultConfig = async (config) => {
     config.cacheDir = config.cacheDir ?? '.zuby-cache';
     config.output = config.output ?? 'static';
     config.prerenderPaths = config.prerenderPaths ?? [];
+    config.plugins = await normalizePlugins([
+        ...getBuiltInPlugins(),
+        ...(config.jsx?.getPlugins() ?? []),
+        ...(config.plugins ?? []),
+    ]);
     // Default server config
     config.server = config.server ?? {};
     config.server.host = config.server.host ?? '127.0.0.1';
@@ -116,19 +128,15 @@ export const mergeDefaultConfig = async (config) => {
     config.vite.build.ssrEmitAssets = config.vite.build.ssrEmitAssets ?? true;
     config.vite.build.modulePreload = { polyfill: false };
     config.vite.optimizeDeps = config.vite.optimizeDeps ?? {};
-    // Merge built-in plugins with user plugins
-    config.vite.plugins = [
-        ...getBuiltInPlugins(),
-        ...(config.jsx?.getPlugins() ?? []),
-        ...(config.vite?.plugins ?? []),
-    ];
+    // Merge Vite plugins with Zuby plugins
+    config.vite.plugins = [...(config.plugins ?? []), ...(config.vite.plugins ?? [])];
     return {
         ...config,
         templateExtensions: ['js', 'jsx', 'ts', 'tsx'],
     };
 };
 /**
- * This function returns the array of built-in Zuby plugins.
+ * This function returns the array of built-in plugins.
  * Check which framework components are relying on each plugin
  * before removing any of them.
  */
@@ -139,5 +147,60 @@ export const getBuiltInPlugins = () => {
         chunkNamingPlugin(),
         manifestPlugin(),
         prerenderPlugin(),
+        standaloneBuildPlugin(),
     ];
 };
+/**
+ * Executes the Zuby plugins for the given hook.
+ * @param config The ZubyConfig or ZubyInternalConfig object.
+ * @param hookName The name of the hook to execute.
+ * @param params Additional params to pass to the plugins.
+ * @param beforeHook Callback function to execute before each plugin hook.
+ * @param afterHook Callback function to execute after each plugin hook.
+ * @example executePlugins(config, 'zuby:config:setup', { config, logger })
+ */
+export const executePlugins = async (config, hookName, params = {}, beforeHook = () => { }, afterHook = () => { }) => {
+    const logger = config.customLogger ||
+        createLogger(config.logLevel, {
+            allowClearScreen: false,
+            prefix: '[Zuby]',
+        });
+    const command = process.env.NODE_ENV === 'production' ? 'build' : 'dev';
+    const plugins = config.plugins || [];
+    for (const plugin of plugins) {
+        // Skip if the plugin is not an object
+        // or if it doesn't have hooks
+        if (!plugin || !('hooks' in plugin))
+            continue;
+        const zubyPlugin = plugin;
+        const hooks = zubyPlugin?.hooks || {};
+        const hook = hooks[hookName];
+        // Skip if the hook has invalid type
+        if (!hook || typeof hook !== 'function')
+            continue;
+        // Execute the callback function before each hook
+        await beforeHook(zubyPlugin);
+        // Execute the hook
+        const hookResult = await hook({
+            ...params,
+            config,
+            logger,
+            command,
+        });
+        // Execute the callback function after each hook
+        await afterHook(zubyPlugin, hookResult);
+    }
+};
+/**
+ * Normalizes the plugins to common array format.
+ * @param plugins
+ */
+export const normalizePlugins = async (plugins) => {
+    // Resolve the plugins if they are promises
+    const resolvePlugins = await Promise.resolve(plugins);
+    return resolvePlugins
+        // Flatten the array and normalize inner arrays
+        .flatMap(plugin => (Array.isArray(plugin) ? normalizePlugins(plugin) : [plugin]))
+        // Remove false, undefined, null values
+        .filter(plugin => !!plugin);
+};

package/defineConfig.d.ts

@@ -4,10 +4,12 @@ import { ZubyConfig } from './types.js';
  *
  * It is not required, but it provides type safety and autocompletion in your IDE.
  * See the full Zuby Configuration API Documentation
+ *
+ * @link https://zuby.futrou.com/reference/configuration
  * @param config
  * @example defineConfig({
  *   outDir: 'build',
  *   srcDir: './',
  * })
  */
-export declare const defineConfig: (config: ZubyConfig) => ZubyConfig;
+export declare const defineConfig: (config: ZubyConfig | (() => ZubyConfig | Promise<ZubyConfig>)) => ZubyConfig | Promise<ZubyConfig>;

package/defineConfig.js

@@ -3,6 +3,8 @@
  *
  * It is not required, but it provides type safety and autocompletion in your IDE.
  * See the full Zuby Configuration API Documentation
+ *
+ * @link https://zuby.futrou.com/reference/configuration
  * @param config
  * @example defineConfig({
  *   outDir: 'build',
@@ -10,5 +12,8 @@
  * })
  */
 export const defineConfig = (config) => {
+    if (typeof config === 'function') {
+        return config();
+    }
     return config;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zuby",
-  "version": "1.0.42",
+  "version": "1.0.44",
   "description": "Zuby.js is framework for building SPA apps using Vite",
   "type": "module",
   "main": "index.js",

package/plugins/chunkNamingPlugin/index.d.ts

@@ -1,6 +1,6 @@
-import { Plugin } from 'vite';
+import { Plugin as VitePlugin } from 'vite';
 /**
  * This is internal plugin
  * which configure a custom chunk naming for the build.
  */
-export default function chunkNamingPlugin(): Plugin;
+export default function chunkNamingPlugin(): VitePlugin;

package/plugins/compileTimePlugin/index.d.ts

@@ -1,4 +1,4 @@
-import { Plugin } from 'vite';
+import { Plugin as VitePlugin } from 'vite';
 type MaybePromise<T> = T | Promise<T>;
 export type CompileTimeFunctionArgs = {
     /** Root directory of the Vite project */
@@ -20,6 +20,6 @@ export type CompileTimeFunction = (args: CompileTimeFunctionArgs) => CompileTime
  * This plugin is just modified version of vite-plugin-compile-time plugin.
  * See: https://github.com/egoist/vite-plugin-compile-time for more details.
  */
-export default function createPlugins(): Plugin[];
+export default function createPlugins(): VitePlugin;
 export declare function resolveImport(importPath: string, projectRoot?: string): string | undefined;
 export {};

package/plugins/compileTimePlugin/index.js

@@ -17,80 +17,76 @@ export default function createPlugins() {
     let useSourceMap = false;
     const loadCache = new Map();
     let root = process.cwd();
-    return [
-        {
-            name: 'zuby-compile-time-plugin',
-            enforce: 'pre',
-            configResolved(config) {
-                useSourceMap = !!config.build.sourcemap;
-                root = config.root;
-            },
-            configureServer(server) {
-                server.watcher.on('all', (_, id) => {
-                    for (const [k, cache] of loadCache) {
-                        if (cache.watchFiles?.includes(id)) {
-                            loadCache.delete(k);
-                        }
+    return {
+        name: 'zuby-compile-time-plugin',
+        enforce: 'pre',
+        configResolved(config) {
+            useSourceMap = !!config.build.sourcemap;
+            root = config.root;
+        },
+        configureServer(server) {
+            server.watcher.on('all', (_, id) => {
+                for (const [k, cache] of loadCache) {
+                    if (cache.watchFiles?.includes(id)) {
+                        loadCache.delete(k);
                     }
-                });
-            },
-            async transform(code, id) {
-                if ((id.includes('node_modules') && !id.includes('zuby')) ||
-                    !/\.(js|ts|jsx|tsx|mjs|cjs)(\?.+)?$/.test(id)) {
-                    return;
                 }
-                const m = [
-                    ...code.matchAll(/import\.meta\.compileTime(?:<[\w]*>)?\(['"`]([^'"`]+)['"`]\)/g),
-                ];
-                if (m.length === 0)
-                    return;
-                const s = new MagicString(code);
-                const dir = dirname(id);
-                for (const item of m) {
-                    const start = item.index;
-                    const end = item.index + item[0].length;
-                    const importPath = item[1];
-                    const filepath = resolveImport(importPath, root);
-                    if (!filepath) {
-                        throw new Error(`Cannot resolve module: '${importPath}'`);
-                    }
-                    const cacheKey = filepath;
-                    let cache = loadCache.get(cacheKey);
-                    if (!cache) {
-                        const { mod, dependencies } = await bundleRequire({ filepath });
-                        const defaultExport = mod.default || mod;
-                        cache = (defaultExport && (await defaultExport({ root }))) || {};
-                        cache.watchFiles = [
-                            filepath,
-                            ...(cache.watchFiles || []),
-                            ...dependencies.map(p => resolve(p)),
-                        ];
-                        if (cache.data) {
-                            cache.data = uneval(cache.data);
-                        }
-                        loadCache.set(cacheKey, cache);
-                    }
-                    let replacement = 'null';
-                    if (cache.watchFiles) {
-                        cache.watchFiles.forEach(filepath => {
-                            this.addWatchFile(filepath);
-                        });
-                    }
-                    if (cache.data !== undefined) {
-                        replacement = cache.data;
-                    }
-                    else if (cache.code !== undefined) {
-                        replacement = cache.code;
+            });
+        },
+        async transform(code, id) {
+            if ((id.includes('node_modules') && !id.includes('zuby')) ||
+                !/\.(js|ts|jsx|tsx|mjs|cjs)(\?.+)?$/.test(id)) {
+                return;
+            }
+            const m = [...code.matchAll(/import\.meta\.compileTime(?:<[\w]*>)?\(['"`]([^'"`]+)['"`]\)/g)];
+            if (m.length === 0)
+                return;
+            const s = new MagicString(code);
+            const dir = dirname(id);
+            for (const item of m) {
+                const start = item.index;
+                const end = item.index + item[0].length;
+                const importPath = item[1];
+                const filepath = resolveImport(importPath, root);
+                if (!filepath) {
+                    throw new Error(`Cannot resolve module: '${importPath}'`);
+                }
+                const cacheKey = filepath;
+                let cache = loadCache.get(cacheKey);
+                if (!cache) {
+                    const { mod, dependencies } = await bundleRequire({ filepath });
+                    const defaultExport = mod.default || mod;
+                    cache = (defaultExport && (await defaultExport({ root }))) || {};
+                    cache.watchFiles = [
+                        filepath,
+                        ...(cache.watchFiles || []),
+                        ...dependencies.map(p => resolve(p)),
+                    ];
+                    if (cache.data) {
+                        cache.data = uneval(cache.data);
                     }
-                    s.overwrite(start, end, replacement);
+                    loadCache.set(cacheKey, cache);
+                }
+                let replacement = 'null';
+                if (cache.watchFiles) {
+                    cache.watchFiles.forEach(filepath => {
+                        this.addWatchFile(filepath);
+                    });
+                }
+                if (cache.data !== undefined) {
+                    replacement = cache.data;
+                }
+                else if (cache.code !== undefined) {
+                    replacement = cache.code;
                 }
-                return {
-                    code: s.toString(),
-                    map: useSourceMap ? s.generateMap({ source: id }) : null,
-                };
-            },
+                s.overwrite(start, end, replacement);
+            }
+            return {
+                code: s.toString(),
+                map: useSourceMap ? s.generateMap({ source: id }) : null,
+            };
         },
-    ];
+    };
 }
 export function resolveImport(importPath, projectRoot = process.cwd()) {
     if (isAbsolute(importPath)) {

package/plugins/contextPlugin/index.d.ts

@@ -1,6 +1,6 @@
-import type { PluginOption } from 'vite';
+import type { Plugin as VitePlugin } from 'vite';
 import { Template } from '../../templates/types.js';
-export default function index(): PluginOption;
+export default function index(): VitePlugin;
 export declare function generateCompileTimeContextCode(ssr: boolean): Promise<string>;
 export declare function generateTemplatesCode(ssr: boolean): Promise<string>;
 export declare function generateTemplateCode(template: Template): Promise<string>;

package/plugins/dependenciesPlugin/index.d.ts

@@ -0,0 +1,7 @@
+import { ZubyPlugin } from '../../types.js';
+/**
+ * This is internal plugin
+ * that traces and copies all node_modules and other
+ * dependencies of the build.
+ */
+export default function standaloneBuildPlugin(): ZubyPlugin;

package/plugins/dependenciesPlugin/index.js

@@ -0,0 +1,46 @@
+import { existsSync, mkdirSync } from 'fs';
+import { dirname, join } from 'path';
+import { copyFile } from 'fs/promises';
+import { normalizePath } from '../../utils/pathUtils.js';
+import { nodeFileTrace } from '@vercel/nft';
+import { glob } from 'glob';
+/**
+ * This is internal plugin
+ * that traces and copies all node_modules and other
+ * dependencies of the build.
+ */
+export default function standaloneBuildPlugin() {
+    return {
+        name: 'zuby-dependencies-plugin',
+        description: 'tracing dependencies...',
+        buildStep: true,
+        hooks: {
+            'zuby:build:done': async ({ config, logger }) => {
+                const { outDir } = config;
+                logger?.info(`Tracing production dependencies...`);
+                const serverFiles = await glob(`${normalizePath(outDir)}/server/**/*.js`);
+                const { fileList } = await nodeFileTrace(serverFiles, {
+                    processCwd: process.cwd(),
+                    ignore: (path) => {
+                        return path.startsWith(outDir);
+                    },
+                });
+                logger?.info(`Copying ${fileList.size} files...`);
+                const copyFilePromises = [...fileList].map(async (srcFile) => {
+                    const destFile = normalizePath(join(outDir, srcFile));
+                    const destDir = dirname(destFile);
+                    if (srcFile.startsWith(outDir) || existsSync(destFile)) {
+                        return;
+                    }
+                    if (!existsSync(destDir)) {
+                        mkdirSync(destDir, {
+                            recursive: true,
+                        });
+                    }
+                    return copyFile(srcFile, destFile);
+                });
+                await Promise.all(copyFilePromises);
+            },
+        },
+    };
+}

package/plugins/manifestPlugin/index.d.ts

@@ -1,6 +1,6 @@
-import { Plugin } from 'vite';
+import type { Plugin as VitePlugin } from 'vite';
 /**
  * This is internal plugin
  * which generated and moves required manifest files.
  */
-export default function manifestPlugin(): Plugin;
+export default function manifestPlugin(): VitePlugin;

package/plugins/prerenderPlugin/index.d.ts

@@ -1,6 +1,6 @@
-import { Plugin } from 'vite';
+import { ZubyPlugin } from '../../types.js';
 /**
  * This is internal plugin
  * that pre-renders the pages during the build.
  */
-export default function prerenderPlugin(): Plugin;
+export default function prerenderPlugin(): ZubyPlugin;

package/plugins/prerenderPlugin/index.js

@@ -1,6 +1,5 @@
-import { existsSync, mkdirSync, readFileSync } from 'fs';
+import { existsSync, mkdirSync } from 'fs';
 import { dirname, join, relative, resolve } from 'path';
-import { getZubyInternalConfig } from '../../config.js';
 import chalk from 'chalk';
 import { performance } from 'node:perf_hooks';
 import ZubyRenderer from '../../server/zubyRenderer.js';
@@ -10,115 +9,106 @@ import { OUTPUTS } from '../../types.js';
 import { PATH_TYPES } from '../../templates/types.js';
 import { substitutePathParams } from '../../templates/pathUtils.js';
 import { normalizePath } from '../../utils/pathUtils.js';
-import { HTTP_HEADERS, SERVER_CHUNKS_MANIFEST } from '../../constants.js';
+import { HTTP_HEADERS } from '../../constants.js';
 /**
  * This is internal plugin
  * that pre-renders the pages during the build.
  */
 export default function prerenderPlugin() {
-    let viteConfig;
     return {
         name: 'zuby-prerender-plugin',
-        apply: 'build',
-        enforce: 'post',
-        async configResolved(config) {
-            viteConfig = config;
-        },
-        async closeBundle() {
-            // If the build is not for SSR, then skip the pre-rendering
-            if (!viteConfig?.build.ssr) {
-                return;
-            }
-            const startTime = performance.now();
-            const { srcDir, outDir, customLogger, prerenderPaths, site, output } = await getZubyInternalConfig();
-            const chunksManifestPath = resolve(outDir, SERVER_CHUNKS_MANIFEST);
-            const chunksManifest = existsSync(chunksManifestPath)
-                ? JSON.parse(readFileSync(chunksManifestPath, 'utf-8'))
-                : {};
-            const pages = await getPages();
-            for (const page of pages) {
-                const srcFilename = normalizePath(relative(srcDir, page.filename));
-                const outFilename = chunksManifest[srcFilename]?.[0];
-                if (!outFilename) {
-                    customLogger?.warn(`WARNING: Page "${page.path}" couldn't be pre-rendered because it doesn't have corresponding chunk file.`);
-                    continue;
-                }
-                const modulePath = normalizePath(resolve(outDir, 'server', outFilename.substring(1)));
-                const module = await import(`file:///${modulePath}`);
-                const pagePrerenderValue = module?.prerender && typeof module?.prerender === 'function'
-                    ? await module?.prerender()
-                    : module?.prerender;
-                const globalPrerenderValue = output === OUTPUTS.static;
-                const shouldPrerender = pagePrerenderValue ?? globalPrerenderValue;
-                if (!shouldPrerender)
-                    continue;
-                if (page.pathType === PATH_TYPES.static) {
-                    prerenderPaths.push(page.path);
-                    continue;
-                }
-                if (!module?.prerenderPaths && pagePrerenderValue) {
-                    const exampleParam = page.pathParams?.[0] || '';
-                    const exampleFullPath = substitutePathParams(page.path, { [exampleParam]: 'value3' });
-                    customLogger?.warn(`WARNING: Page "${page.path}" has dynamic path and enabled pre-rendering but doesn't export prerenderPaths property.`);
-                    customLogger?.warn(`1. If you don't want to pre-render this page, you need to export prerender property with false value.`);
-                    customLogger?.warn(`Example: export const prerender = false`);
-                    customLogger?.warn(`2. If you want to pre-render this page, you need to export prerenderPaths property with array of paths.`);
-                    customLogger?.warn(`Example: export const prerenderPaths = [ { "${exampleParam}" : "value" }, { "${exampleParam}" : "value2" }, "${exampleFullPath}" ]\r\n`);
-                }
-                if (!module?.prerenderPaths) {
-                    continue;
-                }
-                const pagePrerenderPaths = typeof module?.prerenderPaths === 'function'
-                    ? await module?.prerenderPaths()
-                    : module?.prerenderPaths;
-                pagePrerenderPaths.forEach((params) => {
-                    // Handle case when path is defined as string
-                    // Example: /products/123
-                    if (typeof params === 'string') {
-                        return prerenderPaths.push(params);
+        description: 'pre-rendering pages...',
+        buildStep: true,
+        hooks: {
+            'zuby:build:done': async ({ config, logger, templates, serverChunksManifest }) => {
+                const { srcDir, outDir, prerenderPaths, site, output } = config;
+                const startTime = performance.now();
+                const pages = await getPages(templates);
+                for (const page of pages) {
+                    const srcFilename = normalizePath(relative(srcDir, page.filename));
+                    const outFilename = serverChunksManifest[srcFilename]?.[0];
+                    if (!outFilename) {
+                        logger?.warn(`WARNING: Page "${page.path}" couldn't be pre-rendered because it doesn't have corresponding chunk file.`);
+                        continue;
                     }
-                    // Handle case when path is defined as object of params
-                    // Example: { id: 123 } => /products/123
-                    if (typeof params === 'object') {
-                        return prerenderPaths.push(substitutePathParams(page.path, params));
+                    const modulePath = normalizePath(resolve(outDir, 'server', outFilename.substring(1)));
+                    const module = await import(`file:///${modulePath}`);
+                    const pagePrerenderValue = module?.prerender && typeof module?.prerender === 'function'
+                        ? await module?.prerender()
+                        : module?.prerender;
+                    const globalPrerenderValue = output === OUTPUTS.static;
+                    const shouldPrerender = pagePrerenderValue ?? globalPrerenderValue;
+                    if (!shouldPrerender)
+                        continue;
+                    if (page.pathType === PATH_TYPES.static) {
+                        prerenderPaths.push(page.path);
+                        continue;
                     }
-                });
-            }
-            customLogger?.info(`${chalk.bgYellow.bold.whiteBright(` Step 3/4 `)} ${chalk.gray(`pre-rendering pages...`)}`);
-            const zubyRenderer = new ZubyRenderer(outDir);
-            await zubyRenderer.init();
-            const reqBaseUrl = `http://${site || 'localhost'}`;
-            const reqOptions = {
-                headers: {
-                    [HTTP_HEADERS.UserAgent]: 'zuby-prerender',
-                },
-            };
-            for (const path of prerenderPaths) {
-                const pageReq = new Request(new URL(path, reqBaseUrl), reqOptions);
-                const propsReq = new Request(new URL(`/_props${path}`, reqBaseUrl), reqOptions);
-                const [pageRes, propsRes] = await Promise.all([
-                    zubyRenderer.render(pageReq),
-                    zubyRenderer.render(propsReq),
-                ]);
-                const [page, props] = await Promise.all([pageRes.text(), propsRes.text()]);
-                const pageContentType = pageRes.headers?.get('content-type');
-                const pageExtension = pageContentType?.startsWith('application/json') ? 'json' : 'html';
-                const pageTarget = join(outDir, 'client', path, `index.${pageExtension}`);
-                const propsTarget = join(outDir, 'client', '_props', path, 'index.json');
-                const pageDir = dirname(pageTarget);
-                const propsDir = dirname(propsTarget);
-                [pageDir, propsDir].forEach(dir => {
-                    if (existsSync(dir))
-                        return;
-                    mkdirSync(dir, {
-                        recursive: true,
+                    if (!module?.prerenderPaths && pagePrerenderValue) {
+                        const exampleParam = page.pathParams?.[0] || '';
+                        const exampleFullPath = substitutePathParams(page.path, { [exampleParam]: 'value3' });
+                        logger?.warn(`WARNING: Page "${page.path}" has dynamic path and enabled pre-rendering but doesn't export prerenderPaths property.`);
+                        logger?.warn(`1. If you don't want to pre-render this page, you need to export prerender property with false value.`);
+                        logger?.warn(`Example: export const prerender = false`);
+                        logger?.warn(`2. If you want to pre-render this page, you need to export prerenderPaths property with array of paths.`);
+                        logger?.warn(`Example: export const prerenderPaths = [ { "${exampleParam}" : "value" }, { "${exampleParam}" : "value2" }, "${exampleFullPath}" ]\r\n`);
+                    }
+                    if (!module?.prerenderPaths) {
+                        continue;
+                    }
+                    const pagePrerenderPaths = typeof module?.prerenderPaths === 'function'
+                        ? await module?.prerenderPaths()
+                        : module?.prerenderPaths;
+                    pagePrerenderPaths.forEach((params) => {
+                        // Handle case when path is defined as string
+                        // Example: /products/123
+                        if (typeof params === 'string') {
+                            return prerenderPaths.push(params);
+                        }
+                        // Handle case when path is defined as object of params
+                        // Example: { id: 123 } => /products/123
+                        if (typeof params === 'object') {
+                            return prerenderPaths.push(substitutePathParams(page.path, params));
+                        }
                     });
-                });
-                await Promise.all([writeFile(pageTarget, page), writeFile(propsTarget, props)]);
-                customLogger.info('[prerender] Pre-rendered path: ' + path);
-            }
-            const finishTime = performance.now();
-            customLogger?.info(chalk.green(`✓ pre-rendered in ${Math.ceil(finishTime - startTime)}ms`));
+                }
+                const zubyRenderer = new ZubyRenderer(outDir);
+                await zubyRenderer.init();
+                const reqBaseUrl = `http://${site || 'localhost'}`;
+                const reqOptions = {
+                    headers: {
+                        [HTTP_HEADERS.UserAgent]: 'zuby-prerender',
+                    },
+                };
+                // Assign all discovered prerender paths to the config for other plugins.
+                config.prerenderPaths = prerenderPaths;
+                for (const path of prerenderPaths) {
+                    const pageReq = new Request(new URL(path, reqBaseUrl), reqOptions);
+                    const propsReq = new Request(new URL(`/_props${path}`, reqBaseUrl), reqOptions);
+                    const [pageRes, propsRes] = await Promise.all([
+                        zubyRenderer.render(pageReq),
+                        zubyRenderer.render(propsReq),
+                    ]);
+                    const [page, props] = await Promise.all([pageRes.text(), propsRes.text()]);
+                    const pageContentType = pageRes.headers?.get('content-type');
+                    const pageExtension = pageContentType?.startsWith('application/json') ? 'json' : 'html';
+                    const pageTarget = join(outDir, 'client', path, `index.${pageExtension}`);
+                    const propsTarget = join(outDir, 'client', '_props', path, 'index.json');
+                    const pageDir = dirname(pageTarget);
+                    const propsDir = dirname(propsTarget);
+                    [pageDir, propsDir].forEach(dir => {
+                        if (existsSync(dir))
+                            return;
+                        mkdirSync(dir, {
+                            recursive: true,
+                        });
+                    });
+                    await Promise.all([writeFile(pageTarget, page), writeFile(propsTarget, props)]);
+                    logger.info('[prerender] Pre-rendered path: ' + path);
+                }
+                const finishTime = performance.now();
+                logger?.info(chalk.green(`✓ pre-rendered in ${Math.ceil(finishTime - startTime)}ms`));
+            },
         },
     };
 }

package/templates/index.js

@@ -98,7 +98,7 @@ export async function getTemplates(cache = true) {
     const { srcDir, i18n, templateExtensions } = await getZubyInternalConfig();
     const pagesDir = normalizePath(join(srcDir, 'pages'));
     const files = await glob(`${pagesDir}/**/*.{${templateExtensions.join(',')}}`);
-    const locales = i18n?.locales || [];
+    const locales = (i18n?.locales || []).filter(locale => locale !== i18n?.defaultLocale);
     const templates = files
         .map(filename => {
         // Normalize the path and slashes to unix style (needed for windows)

package/types.d.ts

@@ -1,10 +1,9 @@
 /// <reference types="node" resolution-mode="require"/>
-import type { UserConfig as ViteUserConfig } from 'vite';
-import type { Plugin as VitePlugin } from 'vite';
-import type { PluginOption as VitePluginOption } from 'vite';
+import type { UserConfig as ViteUserConfig, InlineConfig as ViteInlineConfig, PluginOption as VitePluginOption, Plugin as VitePlugin } from 'vite';
 import { ZubyLogger } from './logger/types.js';
 import ReadableStream = NodeJS.ReadableStream;
-import { PathParamsType } from './templates/types.js';
+import { PathParamsType, Template } from './templates/types.js';
+import ZubyDevServer from './server/zubyDevServer.js';
 export interface ZubyConfig {
     /**
      * The JSX provider which will be used to render the pages.
@@ -66,6 +65,11 @@ export interface ZubyConfig {
      * @example ['/products/1', '/products/2']
      */
     prerenderPaths?: string[];
+    /**
+     * List of plugins that use either the Zuby plugin API or Vite plugin API.
+     * @default []
+     */
+    plugins?: (ZubyPlugin | VitePluginOption)[];
     /**
      * Set this option to false to disable the minification of pre-rendered HTML.
      * @default true
@@ -126,6 +130,12 @@ export interface ZubyInternalConfig extends Required<ZubyConfig> {
      * @default ['tsx', 'jsx', 'ts', 'js', 'mjs', 'md', 'mdx']
      */
     templateExtensions: string[];
+    /**
+     * List of plugins that use either the Zuby plugin API or Vite plugin API
+     * in normalized format.
+     * @default []
+     */
+    plugins: ZubyPlugin[];
 }
 export interface BaseCommandOptions {
     /**
@@ -169,11 +179,9 @@ export declare const OUTPUTS: {
     server: string;
 };
 export type Output = (typeof OUTPUTS)[keyof typeof OUTPUTS];
-export interface ZubyPlugin extends VitePlugin {
-}
 export interface JsxProvider {
     name: string;
-    getPlugins(): VitePluginOption[] | VitePluginOption[][];
+    getPlugins(): (ZubyPlugin | VitePluginOption)[];
     renderFile: string;
     appTemplateFile: string;
     entryTemplateFile: string;
@@ -201,3 +209,109 @@ export type PrerenderPathsItem = PathParamsType | string;
  * @example export const prerenderPaths = [{ id: 1 }, '/products/2'];
  */
 export type PrerenderPaths = PrerenderPathsItem[] | (() => PrerenderPathsItem[]) | (() => Promise<PrerenderPathsItem[]>);
+export interface ZubyPlugin extends VitePlugin {
+    /**
+     * The name of the plugin.
+     * @example 'zuby-plugin-sitemap'
+     */
+    name: string;
+    /**
+     * The description what the plugin does.
+     * This will be displayed in the CLI during the build/dev process.
+     * @example 'pre-rendering pages'
+     */
+    description?: string;
+    /**
+     * Set this option to true
+     * to include the plugin as build step
+     * that will be shown in the CLI during the build process.
+     * @example Step 4/4 pre-rendering pages...
+     */
+    buildStep?: Boolean;
+    /**
+     * The Zuby plugin API hooks.
+     * Hooks allow you to run custom code at specific points during the build/dev process
+     * and modify the internal Zuby config.
+     */
+    hooks?: {
+        /**
+         * This hook is called before the Zuby config is resolved
+         * and allows you to modify the config.
+         */
+        'zuby:config:setup'?: (params: ZubyConfigSetupHookParams) => void | Promise<void>;
+        /**
+         * This hook is called after the Zuby config is resolved by all plugins
+         * and allows you to get the final config before the build/dev process starts.
+         */
+        'zuby:config:done'?: (params: ZubyConfigDoneHookParams) => void | Promise<void>;
+        /**
+         * This hook is called before the dev server is started
+         * and allows you to modify the server config.
+         */
+        'zuby:dev:setup'?: (params: ZubyDevHookParams) => void | Promise<void>;
+        /**
+         * This hook is called after the dev server is started
+         */
+        'zuby:dev:start'?: (params: ZubyDevHookParams) => void | Promise<void>;
+        /**
+         * This hook is called before the build process starts
+         * and allows you to modify the vite build config.
+         */
+        'zuby:build:setup'?: (params: ZubyBuildSetupHookParams) => void | Promise<void>;
+        /**
+         * This hook is called after the build process starts
+         */
+        'zuby:build:start'?: (params: ZubyBuildHookParams) => void | Promise<void>;
+        /**
+         * This hook is called after the client build is done
+         */
+        'zuby:build:client:done'?: (params: ZubyBuildHookParams) => void | Promise<void>;
+        /**
+         * This hook is called after the server build is done
+         */
+        'zuby:build:server:done'?: (params: ZubyBuildHookParams) => void | Promise<void>;
+        /**
+         * This hook is called after the whole build process is done
+         */
+        'zuby:build:done'?: (params: ZubyBuildDoneHookParams) => void | Promise<void>;
+    };
+}
+export interface ZubyConfigSetupHookParams {
+    config: ZubyConfig;
+    command: 'dev' | 'build';
+}
+export interface ZubyConfigDoneHookParams extends ZubyConfigSetupHookParams {
+    config: ZubyInternalConfig;
+    logger: ZubyLogger;
+}
+export interface ZubyDevHookParams {
+    config: ZubyInternalConfig;
+    logger: ZubyLogger;
+    server: ZubyDevServer;
+}
+export interface ZubyBuildHookParams {
+    config: ZubyInternalConfig;
+    logger: ZubyLogger;
+    templates: Template[];
+}
+export interface ZubyBuildSetupHookParams extends ZubyBuildHookParams {
+    clientViteBuildConfig: ViteInlineConfig;
+    serverViteBuildConfig: ViteInlineConfig;
+}
+export interface ZubyBuildDoneHookParams extends ZubyBuildHookParams {
+    clientChunksManifest: Record<string, string[]>;
+    serverChunksManifest: Record<string, string[]>;
+}
+export type ZubyHookParams = ZubyConfigSetupHookParams | ZubyConfigDoneHookParams | ZubyDevHookParams | ZubyBuildHookParams | ZubyBuildDoneHookParams;
+export declare const PLUGIN_HOOKS: {
+    ZubyConfigSetup: string;
+    ZubyConfigDone: string;
+    ZubyDevSetup: string;
+    ZubyDevStart: string;
+    ZubyBuildSetup: string;
+    ZubyBuildStart: string;
+    ZubyBuildClientDone: string;
+    ZubyBuildServerDone: string;
+    ZubyBuildDone: string;
+};
+export type PluginHook = (typeof PLUGIN_HOOKS)[keyof typeof PLUGIN_HOOKS];

package/types.js

@@ -7,3 +7,17 @@ export const OUTPUTS = {
     static: 'static',
     server: 'server',
 };
+export const PLUGIN_HOOKS = {
+    // Config resolve
+    ZubyConfigSetup: 'zuby:config:setup',
+    ZubyConfigDone: 'zuby:config:done',
+    // Dev cmd
+    ZubyDevSetup: 'zuby:dev:setup',
+    ZubyDevStart: 'zuby:dev:start',
+    // Build cmd
+    ZubyBuildSetup: 'zuby:build:setup',
+    ZubyBuildStart: 'zuby:build:start',
+    ZubyBuildClientDone: 'zuby:build:client:done',
+    ZubyBuildServerDone: 'zuby:build:server:done',
+    ZubyBuildDone: 'zuby:build:done',
+};