zuby 1.0.30 → 1.0.32

package/README.md

@@ -32,6 +32,12 @@ Following integrations are available:
 - [@zubyjs/preact](https://www.npmjs.com/package/@zubyjs/preact) - Preact integration for Zuby.js
 - [@zubyjs/react](https://www.npmjs.com/package/@zubyjs/react) - React integration for Zuby.js
 
+## Acknowledgements
+
+Zuby.js is inspired by [Astro](https://astro.build/), [Next.js](https://nextjs.org/) and [iles](https://iles.pages.dev/)
+to offer familiarity and a quick learning curve for developers but still do things differently.
+You should definitely explore these frameworks too, they are awesome! Maybe you'll find one of them more suitable for your needs.
+
 ## Recommended versions
 
 - Node.js: 18

package/commands/build.d.ts

@@ -1,3 +1,3 @@
-import { BuildCommandOptions, ZubyConfig } from '../types.js';
+import { BuildCommandOptions, ZubyInternalConfig } from '../types.js';
 export default function build(options: BuildCommandOptions): Promise<void>;
-export declare function getEntryFile(zubyConfig: ZubyConfig): Promise<string>;
+export declare function getEntryFile(zubyInternalConfig: ZubyInternalConfig): Promise<string>;

package/commands/build.js

@@ -1,12 +1,11 @@
 import { MODES } from '../types.js';
-import { getZubyConfig } from '../config.js';
+import { 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 { normalizePath } from '../utils/pathUtils.js';
 import { existsSync, rmSync, writeFileSync, copyFileSync, mkdirSync } from 'fs';
-import { ZUBY_CONFIG_FILE } from '../constants.js';
 import { TEMPLATES } from '../templates/types.js';
 import { glob } from 'glob';
 import { fileURLToPath } from 'url';
@@ -16,8 +15,8 @@ import { copyFile } from 'fs/promises';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 export default async function build(options) {
-    const zubyConfig = await getZubyConfig(options.configFile);
-    const { vite: viteConfig, customLogger: logger, outDir = '' } = zubyConfig;
+    const zubyInternalConfig = await getZubyInternalConfig(options.configFile);
+    const { vite: viteConfig, customLogger: logger, outDir, srcDir, publicDir, configFilePath, } = zubyInternalConfig;
     process.env.NODE_ENV = MODES.production;
     logger?.info(getTitle(chalk.gray(`building for production...`)));
     // Clean build directory
@@ -26,8 +25,9 @@ export default async function build(options) {
             recursive: true,
         });
     }
-    // Load the entry file
-    const entryFile = await getEntryFile(zubyConfig);
+    // 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({
@@ -48,13 +48,15 @@ export default async function build(options) {
     // Server build
     logger?.info(`${chalk.bgYellow.bold.whiteBright(` Step 2/4 `)} ${chalk.gray(`building server...`)}`);
     await viteBuild({
-        configFile: false,
         ...viteConfig,
+        configFile: false,
+        publicDir: false,
         build: {
             ...viteConfig?.build,
             outDir: normalizePath(join(outDir, 'server')),
             ssr: normalizePath(entryFile),
-            ssrManifest: true,
+            ssrManifest: 'ssr-manifest.json',
+            target: 'node18',
         },
         optimizeDeps: {
             ...viteConfig?.optimizeDeps,
@@ -66,10 +68,9 @@ export default async function build(options) {
         mode: MODES.production,
     });
     // Add serialized zuby config to build directory
-    writeFileSync(normalizePath(join(outDir, ZUBY_CONFIG_FILE.replace(/\.mjs$/, '.json'))), JSON.stringify(zubyConfig, null, 2));
+    writeFileSync(normalizePath(join(outDir, 'zuby.config.json')), JSON.stringify(zubyInternalConfig, null, 2));
     // Add standalone server assets
     copyFileSync(normalizePath(join(__dirname, '..', 'server', 'index.js')), normalizePath(join(outDir, 'server.mjs')));
-    copyFileSync(normalizePath(join(__dirname, '..', 'server', 'expressApp.cjs')), normalizePath(join(outDir, 'expressApp.cjs')));
     const { name, version } = getZubyPackageConfig();
     // Write package.json
     writeFileSync(normalizePath(join(outDir, 'package.json')), JSON.stringify({
@@ -102,14 +103,10 @@ export default async function build(options) {
     await Promise.all(copyFilePromises);
     logger?.info(`Done! 🎉`);
 }
-export async function getEntryFile(zubyConfig) {
-    const { srcDir = '', pageExtensions = [], jsx, customLogger: logger } = zubyConfig;
-    const userEntryFile = (await glob(`${normalizePath(srcDir)}${TEMPLATES.entry}.{${pageExtensions.join(',')}}`)).pop();
-    const entryFile = userEntryFile || jsx?.entryTemplateFile;
-    if (!entryFile) {
-        logger?.error(`No entry template is available. Please create a file named '${TEMPLATES.entry}' in your project directory or use different jsx.`);
-        process.exit(1);
-    }
+export async function getEntryFile(zubyInternalConfig) {
+    const { srcDir, templateExtensions, jsx, customLogger: logger } = zubyInternalConfig;
+    const userEntryFile = (await glob(`${normalizePath(srcDir)}${TEMPLATES.entry}.{${templateExtensions.join(',')}}`)).pop();
+    const entryFile = userEntryFile || jsx.entryTemplateFile;
     if (userEntryFile) {
         logger?.info(chalk.gray(`Using custom entry template: '${userEntryFile}'`));
     }

package/commands/dev.js

@@ -1,5 +1,5 @@
 import { MODES } from '../types.js';
-import { getZubyConfig } from '../config.js';
+import { getZubyInternalConfig } from '../config.js';
 import { createServer } from 'vite';
 import { normalizePath } from '../utils/pathUtils.js';
 import { join } from 'path';
@@ -7,7 +7,7 @@ import { performance } from 'node:perf_hooks';
 import { getTitle } from '../branding.js';
 import chalk from 'chalk';
 export default async function dev(options) {
-    const { vite: viteConfig, customLogger: logger, outDir = '', } = await getZubyConfig(options.configFile);
+    const { vite: viteConfig, customLogger: logger, outDir = '', } = await getZubyInternalConfig(options.configFile);
     const port = options.port ? Number(options.port) : viteConfig?.server?.port;
     const host = options.host || viteConfig?.server?.host;
     const mode = MODES.development;

package/commands/index.js

@@ -11,21 +11,21 @@ program
     .command('dev')
     .description('Starts the development server')
     .option('-p, --port <port>', 'Port to use for the dev server', '3000')
-    .option('-h, --host <host>', 'Host to use for the dev server', 'localhost')
-    .option('-c, --config-file <file>', 'The relative path to file with Zuby config', 'zuby.config.mjs')
+    .option('-h, --host <host>', 'Host to use for the dev server', '127.0.0.1')
+    .option('-c, --config-file <file>', 'The relative path to file with Zuby config')
     .action(async (options) => dev(options));
 program
     .command('preview')
     .alias('start')
     .description('Starts the preview server for the production build')
     .option('-p, --port <port>', 'Port to use for the dev server', '3000')
-    .option('-h, --host <host>', 'Host to use for the dev server', 'localhost')
-    .option('-c, --config-file <file>', 'The relative path to file with Zuby config', 'zuby.config.mjs')
+    .option('-h, --host <host>', 'Host to use for the dev server', '127.0.0.1')
+    .option('-c, --config-file <file>', 'The relative path to file with Zuby config')
     .action(async (options) => preview(options));
 program
     .command('build')
     .description('Builds the app for production')
-    .option('-c, --config-file <file>', 'The relative path to file with Zuby config', 'zuby.config.mjs')
+    .option('-c, --config-file <file>', 'The relative path to file with Zuby config')
     .action(async (options) => build(options));
 program
     .command('init')

package/commands/preview.js

@@ -1,9 +1,9 @@
-import { getZubyConfig } from '../config.js';
+import { getZubyInternalConfig } from '../config.js';
 import { existsSync } from 'fs';
 import { normalizePath } from '../utils/pathUtils.js';
 import { resolve } from 'path';
 export default async function preview(options) {
-    const { outDir = '' } = await getZubyConfig(options.configFile);
+    const { outDir } = await getZubyInternalConfig(options.configFile);
     if (outDir && !existsSync(outDir)) {
         throw new Error(`The outDir '${outDir}' does not exist. Did you forget to run 'zuby build' first?`);
     }

package/config.d.ts

@@ -1,16 +1,30 @@
-import { ZubyConfig } from './types.js';
+import { ZubyConfig, ZubyInternalConfig } from './types.js';
 /**
- * This function loads the config file and returns the config object with default values.
- * It also caches the config object for future use.
- * @param configFile
+ * Returns the path to the ZubyConfig file.
+ */
+export declare const getDefaultConfigPath: () => string | undefined;
+/**
+ * This function loads the config file and returns the config object.
+ */
+export declare const getZubyConfig: (configFilePath?: string) => Promise<ZubyConfig>;
+/**
+ * This function loads the ZubyConfig file and returns the ZubyInternalConfig object
+ * with default values added.
+ * @param configFilePath
  * @param cache
  */
-export declare const getZubyConfig: (configFile?: string, cache?: boolean) => Promise<ZubyConfig>;
+export declare const getZubyInternalConfig: (configFilePath?: string, cache?: boolean) => Promise<ZubyInternalConfig>;
 /**
  * Adds default values to the config object.
  * @param config
  */
-export declare const mergeDefaultConfig: (config?: ZubyConfig) => Promise<ZubyConfig>;
+export declare const validateConfig: (config: ZubyConfig) => void;
+/**
+ * Adds default values to the ZubyConfig object
+ * and returns the ZubyInternalConfig object.
+ * @param config
+ */
+export declare const mergeDefaultConfig: (config: ZubyConfig) => Promise<ZubyInternalConfig>;
 /**
  * This function returns the array of built-in Zuby plugins.
  * Check which framework components are relying on each plugin

package/config.js

@@ -1,55 +1,75 @@
 import { ZUBY_CONFIG_FILE } from './constants.js';
 import { existsSync } from 'fs';
 import { bundleRequire } from 'bundle-require';
-import { getApps, getErrors, getInnerLayouts, getLayouts, getPages, getTemplates, } from './templates/index.js';
 import { createLogger } from './logger/index.js';
 // Plugins
 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';
-let zubyConfig;
+let zubyInternalConfig;
 /**
- * This function loads the config file and returns the config object with default values.
- * It also caches the config object for future use.
- * @param configFile
- * @param cache
+ * Returns the path to the ZubyConfig file.
  */
-export const getZubyConfig = async (configFile = ZUBY_CONFIG_FILE, cache = true) => {
-    // Return the cached config if it exists
-    if (cache && zubyConfig)
-        return zubyConfig;
+export const getDefaultConfigPath = () => {
     // Find the config file with various extensions
-    const foundConfigFile = [
-        configFile,
-        configFile.replace(/\.mjs$/, '.js'),
-        configFile.replace(/\.mjs$/, '.ts'),
-        configFile.replace(/\.mjs$/, '.json'),
+    return [
+        ZUBY_CONFIG_FILE,
+        ZUBY_CONFIG_FILE.replace(/\.mjs$/, '.js'),
+        ZUBY_CONFIG_FILE.replace(/\.mjs$/, '.ts'),
     ].find(file => existsSync(file));
-    if (!foundConfigFile) {
-        throw new Error(`Config file does not exist: ${configFile}`);
+};
+/**
+ * This function loads the config file and returns the config object.
+ */
+export const getZubyConfig = async (configFilePath) => {
+    configFilePath = configFilePath || getDefaultConfigPath();
+    if (!configFilePath || !existsSync(configFilePath)) {
+        throw new Error(`ZubyConfig file was not found. Please create a zuby.config.js file in the root of your project.`);
     }
     // Loads the module regardless of the module format
     // and transpiles typescript if needed
     const { mod } = await bundleRequire({
-        filepath: foundConfigFile,
+        filepath: configFilePath,
     });
     // Find the default export and cache the config
-    zubyConfig = mod.default || mod;
+    const zubyConfig = mod.default || mod;
     if (!zubyConfig) {
-        throw new Error(`No valid default export found in config file: ${foundConfigFile}`);
+        throw new Error(`No valid default export found in ZubyConfig file: ${configFilePath}`);
     }
-    zubyConfig = await mergeDefaultConfig(zubyConfig);
-    // Check if the user has provided the Jsx Provider
-    if (!zubyConfig.jsx)
-        throw new Error('You must provide the JSX provider.');
     return zubyConfig;
 };
+/**
+ * This function loads the ZubyConfig file and returns the ZubyInternalConfig object
+ * with default values added.
+ * @param configFilePath
+ * @param cache
+ */
+export const getZubyInternalConfig = async (configFilePath, cache = true) => {
+    // Return the cached config if it exists
+    if (cache && zubyInternalConfig)
+        return zubyInternalConfig;
+    const zubyConfig = await getZubyConfig(configFilePath);
+    zubyConfig.configFilePath = configFilePath;
+    validateConfig(zubyConfig);
+    zubyInternalConfig = await mergeDefaultConfig(zubyConfig);
+    return zubyInternalConfig;
+};
 /**
  * Adds default values to the config object.
  * @param config
  */
-export const mergeDefaultConfig = async (config = {}) => {
+export const validateConfig = (config) => {
+    if (!config.jsx) {
+        throw new Error(`No jsxProvider found in ZubyInternalConfig. The 'jsx' property must be a JsxProvider instance.`);
+    }
+};
+/**
+ * Adds default values to the ZubyConfig object
+ * and returns the ZubyInternalConfig object.
+ * @param config
+ */
+export const mergeDefaultConfig = async (config) => {
     // Call the jsx function if user forgot to call it
     if (typeof config.jsx === 'function') {
         config.jsx = config.jsx();
@@ -60,10 +80,9 @@ export const mergeDefaultConfig = async (config = {}) => {
     config.outDir = config.outDir ?? 'build';
     config.output = config.output ?? 'static';
     config.prerenderPaths = config.prerenderPaths ?? [];
-    config.pageExtensions = config.pageExtensions ?? ['tsx', 'jsx', 'ts', 'js', 'mjs'];
     // Default server config
     config.server = config.server ?? {};
-    config.server.host = config.server.host ?? 'localhost';
+    config.server.host = config.server.host ?? '127.0.0.1';
     config.server.port = config.server.port ?? 3000;
     // Add minification
     config.minifyCSS = config.minifyCSS ?? true;
@@ -94,16 +113,10 @@ export const mergeDefaultConfig = async (config = {}) => {
         ...(config.jsx?.getPlugins() ?? []),
         ...(config.vite?.plugins ?? []),
     ];
-    // Load templates
-    const templates = await getTemplates();
-    config.templates = config.templates ?? {};
-    config.templates.pages = config.templates.pages ?? (await getPages(templates));
-    config.templates.apps = config.templates.apps ?? (await getApps(templates));
-    config.templates.layouts = config.templates.layouts ?? (await getLayouts(templates));
-    config.templates.innerLayouts =
-        config.templates.innerLayouts ?? (await getInnerLayouts(templates));
-    config.templates.errors = config.templates.errors ?? (await getErrors(templates));
-    return config;
+    return {
+        ...config,
+        templateExtensions: ['js', 'jsx', 'ts', 'tsx'],
+    };
 };
 /**
  * This function returns the array of built-in Zuby plugins.

package/context/index.d.ts

@@ -1,18 +1,19 @@
 import { ZubyRawContext } from './types.js';
-declare class ZubyContext {
+export declare class ZubyContext {
     readonly rawContext: ZubyRawContext;
     constructor(rawContext: ZubyRawContext);
-    get title(): string | undefined;
-    set title(title: string | undefined);
-    get currentPath(): string | undefined;
     get templates(): {
         pages?: import("../templates/types.js").LazyTemplate[] | undefined;
         apps?: import("../templates/types.js").LazyTemplate[] | undefined;
         errors?: import("../templates/types.js").LazyTemplate[] | undefined;
         layouts?: import("../templates/types.js").LazyTemplate[] | undefined;
         innerLayouts?: import("../templates/types.js").LazyTemplate[] | undefined;
+        apis?: import("../templates/types.js").LazyTemplate[] | undefined;
     } | undefined;
-    update: (newContext: ZubyRawContext) => this;
+    get site(): string | undefined;
+    get generator(): string | undefined;
+    get version(): string | undefined;
+    get renderToStream(): import("../types.js").RenderToStream | undefined;
+    get renderToString(): import("../types.js").RenderToString | undefined;
 }
 export declare const getContext: () => ZubyContext;
-export {};

package/context/index.js

@@ -1,29 +1,24 @@
-class ZubyContext {
+export class ZubyContext {
     constructor(rawContext) {
-        this.update = (newContext) => {
-            Object.assign(this.rawContext, newContext);
-            return this;
-        };
         this.rawContext = rawContext;
     }
-    get title() {
-        if (typeof document !== 'undefined' && document.title) {
-            this.rawContext.title = document.title;
-            return document.title;
-        }
-        return this.rawContext.title;
+    get templates() {
+        return this.rawContext.templates;
     }
-    set title(title) {
-        if (typeof document !== 'undefined' && document.title) {
-            this.rawContext.title = document.title = title || '';
-        }
-        this.rawContext.title = title;
+    get site() {
+        return this.rawContext.site;
     }
-    get currentPath() {
-        return this.rawContext.currentPath;
+    get generator() {
+        return this.rawContext.generator;
     }
-    get templates() {
-        return this.rawContext.templates;
+    get version() {
+        return this.rawContext.version;
+    }
+    get renderToStream() {
+        return this.rawContext.render?.renderToStream;
+    }
+    get renderToString() {
+        return this.rawContext.render?.renderToString;
     }
 }
 const getRawContext = () => {

package/context/types.d.ts

@@ -1,4 +1,5 @@
 import { LazyTemplate } from '../templates/types.js';
+import { RenderToStream, RenderToString } from '../types.js';
 export interface ZubyRawContext {
     /**
      * The array with templates.
@@ -9,13 +10,28 @@ export interface ZubyRawContext {
         errors?: LazyTemplate[];
         layouts?: LazyTemplate[];
         innerLayouts?: LazyTemplate[];
+        apis?: LazyTemplate[];
     };
     /**
-     * The current path of the page in both client and server env.
+     * The render module from JsxProvider.
      */
-    currentPath?: string;
+    render?: {
+        renderToString?: RenderToString;
+        renderToStream?: RenderToStream;
+    };
+    /**
+     * The URL of the site
+     * @example https://example.com
+     */
+    site?: string;
+    /**
+     * The name of the generator together with its version number
+     * @example Zuby.js 1.0.0
+     */
+    generator?: string;
     /**
-     * The current title of the page in both client and server env.
+     * The version of used Zuby.js
+     * @example 1.0.0
      */
-    title?: string;
+    version?: string;
 }

package/package.json

@@ -1,16 +1,15 @@
 {
   "name": "zuby",
-  "version": "1.0.30",
+  "version": "1.0.32",
   "description": "Zuby.js is framework for building SPA apps using Vite",
   "type": "module",
   "main": "index.js",
   "scripts": {
     "release": "cd ./dist && npm publish --access public && cd ..",
-    "build": "rm -rf dist/ && tsc && cp -rf package.json README.md src/examples dist/ && npm run bundle-server && npm run bundle-express",
+    "build": "rm -rf dist/ && tsc && cp -rf package.json README.md src/examples dist/ && npm run bundle-server",
     "bundle-server": "esbuild src/server/index.ts --bundle --platform=node --format=esm  --outfile=dist/server/index.js",
-    "bundle-express": "esbuild src/server/expressApp.ts --bundle --platform=node --format=cjs --minify --outfile=dist/server/expressApp.cjs",
     "watch-build": "npm run build && tsc --watch",
-    "push-build": "npm run build && cd dist && npm link && cd ..",
+    "push-build": "npm run build && cd dist && yalc push --force && cd ..",
     "test": "exit 0"
   },
   "publishConfig": {
@@ -32,9 +31,7 @@
     "vite": "^4.4.11"
   },
   "devDependencies": {
-    "@types/express": "^4.17.20",
-    "@types/inquirer": "^9.0.6",
-    "express": "^4.18.2"
+    "@types/inquirer": "^9.0.6"
   },
   "bin": {
     "zuby": "./commands/index.js"

package/pageContext/index.d.ts

@@ -0,0 +1,35 @@
+import { ZubyContext } from '../context/index.js';
+export declare class ZubyPageContext {
+    protected _url: URL;
+    protected _title: string;
+    protected _request?: Request;
+    protected _params: Record<string, string>;
+    protected _clientAddress?: string;
+    protected _zubyContext: ZubyContext;
+    constructor(options: {
+        url?: URL;
+        title?: string;
+        request?: Request;
+        response?: Response;
+        clientAddress?: string;
+    });
+    get url(): URL;
+    get title(): string;
+    set title(title: string);
+    get request(): Request | undefined;
+    get params(): Record<string, string>;
+    set params(params: Record<string, string>);
+    get clientAddress(): string | undefined;
+    get isBrowserEnv(): boolean;
+    get site(): string | undefined;
+    get generator(): string | undefined;
+    get version(): string | undefined;
+    get templates(): {
+        pages?: import("../templates/types.js").LazyTemplate[] | undefined;
+        apps?: import("../templates/types.js").LazyTemplate[] | undefined;
+        errors?: import("../templates/types.js").LazyTemplate[] | undefined;
+        layouts?: import("../templates/types.js").LazyTemplate[] | undefined;
+        innerLayouts?: import("../templates/types.js").LazyTemplate[] | undefined;
+        apis?: import("../templates/types.js").LazyTemplate[] | undefined;
+    } | undefined;
+}

package/pageContext/index.js

@@ -0,0 +1,56 @@
+import { getContext } from '../context/index.js';
+export class ZubyPageContext {
+    constructor(options) {
+        this._url = options?.url || new URL('http://localhost/');
+        this._title = options?.title || '';
+        this._request = options?.request;
+        this._params = {};
+        this._clientAddress = options?.clientAddress;
+        this._zubyContext = getContext();
+    }
+    get url() {
+        if (this.isBrowserEnv) {
+            return new URL(window.location.href);
+        }
+        return this._url;
+    }
+    get title() {
+        if (this.isBrowserEnv) {
+            this._title = document.title;
+        }
+        return this._title;
+    }
+    set title(title) {
+        if (this.isBrowserEnv) {
+            document.title = title;
+        }
+        this._title = title;
+    }
+    get request() {
+        return this._request;
+    }
+    get params() {
+        return this._params;
+    }
+    set params(params) {
+        this._params = params;
+    }
+    get clientAddress() {
+        return this._clientAddress;
+    }
+    get isBrowserEnv() {
+        return typeof window !== 'undefined';
+    }
+    get site() {
+        return this._zubyContext.site;
+    }
+    get generator() {
+        return this._zubyContext.generator;
+    }
+    get version() {
+        return this._zubyContext.version;
+    }
+    get templates() {
+        return this._zubyContext.templates;
+    }
+}

package/plugins/contextPlugin/index.d.ts

@@ -4,3 +4,4 @@ export default function index(): PluginOption;
 export declare function generateCompileTimeContextCode(): Promise<string>;
 export declare function generateTemplatesCode(): Promise<string>;
 export declare function generateTemplateCode(template: Template): Promise<string>;
+export declare function generateRenderCode(): Promise<string>;

package/plugins/contextPlugin/index.js

@@ -1,6 +1,8 @@
-import { getZubyConfig } from '../../config.js';
+import { getZubyInternalConfig } from '../../config.js';
 import { relative } from 'path';
 import { normalizePath } from '../../utils/pathUtils.js';
+import { getZubyPackageConfig } from '../../packageConfig.js';
+import { getApis, getApps, getErrors, getInnerLayouts, getLayouts, getPages, getTemplates, } from '../../templates/index.js';
 let viteConfig;
 export default function index() {
     return {
@@ -19,21 +21,36 @@ export default function index() {
     };
 }
 export async function generateCompileTimeContextCode() {
+    const { site } = await getZubyInternalConfig();
+    const { version } = await getZubyPackageConfig();
     return `globalThis.ZubyRawContext = {
         ...(globalThis.ZubyRawContext || {}),
         templates: ${await generateTemplatesCode()},
+        render: ${await generateRenderCode()},
+        site: '${site || ''}',
+        generator: 'Zuby.js ${version}',
+        version: '${version}',
     };`;
 }
 export async function generateTemplatesCode() {
-    const { templates } = await getZubyConfig();
-    const pagesCode = await Promise.all(templates?.pages?.map(generateTemplateCode) || []);
-    const appsCode = await Promise.all(templates?.apps?.map(generateTemplateCode) || []);
-    const errorsCode = await Promise.all(templates?.errors?.map(generateTemplateCode) || []);
+    const templates = await getTemplates();
+    const pages = await getPages(templates);
+    const apps = await getApps(templates);
+    const layouts = await getLayouts(templates);
+    const innerLayouts = await getInnerLayouts(templates);
+    const errors = await getErrors(templates);
+    const apis = await getApis(templates);
+    const pagesCode = await Promise.all(pages.map(generateTemplateCode) || []);
+    const appsCode = await Promise.all(apps.map(generateTemplateCode) || []);
+    const errorsCode = await Promise.all(errors.map(generateTemplateCode) || []);
     const layoutsCode = viteConfig?.build.ssr
-        ? await Promise.all(templates?.layouts?.map(generateTemplateCode) || [])
+        ? await Promise.all(layouts.map(generateTemplateCode) || [])
         : [];
     const innerLayoutsCode = viteConfig?.build.ssr
-        ? await Promise.all(templates?.innerLayouts?.map(generateTemplateCode) || [])
+        ? await Promise.all(innerLayouts.map(generateTemplateCode) || [])
+        : [];
+    const apisCode = viteConfig?.build.ssr
+        ? await Promise.all(apis.map(generateTemplateCode) || [])
         : [];
     return `{
         pages: [${pagesCode.join(',')}],
@@ -41,6 +58,7 @@ export async function generateTemplatesCode() {
         errors: [${errorsCode.join(',')}],
         layouts: [${layoutsCode.join(',')}],
         innerLayouts: [${innerLayoutsCode.join(',')}],
+        apis: [${apisCode.join(',')}],
     }`;
 }
 export async function generateTemplateCode(template) {
@@ -49,7 +67,14 @@ export async function generateTemplateCode(template) {
         path: "${template.path}",
         pathRegex: ${template.pathRegex},
         pathParams: ${JSON.stringify(template.pathParams)},
+        pathType: "${template.pathType}",
         templateType: "${template.templateType}",
         component: () => import("${template.filename}"),
     }`;
 }
+export async function generateRenderCode() {
+    const { jsx } = await getZubyInternalConfig();
+    if (!viteConfig?.build.ssr)
+        return '{}';
+    return `await import("${jsx.renderFile}")`;
+}