rasengan 1.0.0-beta.50 → 1.0.0-beta.51

package/bin.js

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+
+// Import `process` explicitly if needed (e.g., in certain runtime environments).
+import process from 'process';
+
+// If not already set, default `NODE_ENV=development`
+process.env.NODE_ENV = process.env.NODE_ENV ?? 'development';
+
+// Import and execute the CLI script
+import('./lib/esm/cli/index.js').catch((err) => {
+  console.error('Failed to start the Rasengan CLI:', err);
+  process.exit(1);
+});

package/lib/esm/cli/index.js

@@ -1,138 +1,40 @@
-#!/usr/bin/env node
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
-    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
-import chalk from "chalk";
-import { Command } from "commander";
-import { execa } from "execa";
-// @ts-ignore
-import path from "node:path";
-import { resolvePath } from "../config/index.js";
-var program = new Command();
+import chalk from 'chalk';
+import { Command } from 'commander';
+import { execa } from 'execa';
+const program = new Command();
 program
-    .name(chalk.blue("rasengan"))
-    .version("1.0.0", "-v, --version", "Output the current version number");
+    .name(chalk.blue('rasengan'))
+    .version('1.0.0', '-v, --version', 'Output the current version number');
 // Handle the dev command
 program
-    .command("dev")
-    .option("-p <port>")
-    .description("Start development server")
-    .action(function (_a) { return __awaiter(void 0, [_a], void 0, function (_b) {
-    var convertedPort;
-    var port = _b.p;
-    return __generator(this, function (_c) {
-        convertedPort = Number(port);
-        // Checking port
-        if (port &&
-            (isNaN(convertedPort) || convertedPort < 0 || convertedPort > 65535)) {
-            console.log("");
-            console.log(chalk.red("Please provide a valid port number between 0-65535"));
-            console.log("");
-            process.exit(1);
-        }
-        execa("node", ["node_modules/rasengan/server"], {
-            stdio: "inherit",
-            env: __assign(__assign({}, process.env), { PORT: convertedPort ? convertedPort.toString() : undefined }),
-        });
-        return [2 /*return*/];
+    .command('dev')
+    .option('-p <port>')
+    .description('Start development server')
+    .action(async ({ p: port }) => {
+    const convertedPort = Number(port);
+    // Checking port
+    if (port &&
+        (isNaN(convertedPort) || convertedPort < 0 || convertedPort > 65535)) {
+        console.log('');
+        console.log(chalk.red('Please provide a valid port number between 0-65535'));
+        console.log('');
+        process.exit(1);
+    }
+    execa('node', ['node_modules/rasengan/lib/esm/server/dev/server'], {
+        stdio: 'inherit',
+        env: {
+            ...process.env,
+            PORT: convertedPort ? convertedPort.toString() : undefined,
+        },
     });
-}); });
+});
 // Handle the build command
 program
-    .command("build")
-    .description("Build the project")
-    .action(function () {
-    execa("npm", ["run", "build"], {
-        cwd: "node_modules/rasengan",
-        stdio: "inherit", // Pipe child process output to the parent process
+    .command('build')
+    .description('Build the project')
+    .action(async () => {
+    execa('node', ['node_modules/rasengan/lib/esm/scripts/build-command'], {
+        stdio: 'inherit',
     });
 });
-// Handle the prebuild command
-program
-    .command("prepare")
-    .description("Prepare the project")
-    .action(function () { return __awaiter(void 0, void 0, void 0, function () {
-    var configPath, appConfig, server, hostingStrategy;
-    var _a, _b;
-    return __generator(this, function (_c) {
-        switch (_c.label) {
-            case 0:
-                // Displaying the message
-                console.log("");
-                console.log(chalk.blue("Preparing your project for production..."));
-                console.log("");
-                configPath = resolvePath(path.join(process.cwd(), "rasengan.config.js"));
-                return [4 /*yield*/, import(configPath)];
-            case 1:
-                appConfig = (_c.sent()).default;
-                return [4 /*yield*/, appConfig];
-            case 2:
-                server = (_c.sent()).server;
-                hostingStrategy = (_b = (_a = server === null || server === void 0 ? void 0 : server.production) === null || _a === void 0 ? void 0 : _a.hosting) !== null && _b !== void 0 ? _b : "custom";
-                execa("node", ["node_modules/rasengan/lib/esm/scripts/prepare-prod"], {
-                    stdio: "inherit",
-                    // cwd: "node_modules/rasengan/lib/esm/scripts",
-                    env: __assign(__assign({}, process.env), { HOSTING_STRATEGY: hostingStrategy })
-                });
-                return [2 /*return*/];
-        }
-    });
-}); });
-// Handle the start command
-program
-    .command("start")
-    .description("Start the project in production mode")
-    .action(function () { return __awaiter(void 0, void 0, void 0, function () {
-    return __generator(this, function (_a) {
-        execa("npm", ["run", "preview"], {
-            cwd: "node_modules/rasengan",
-            stdio: "inherit", // Pipe child process output to the parent process
-        });
-        return [2 /*return*/];
-    });
-}); });
 program.parse(process.argv);

package/lib/esm/client.js

@@ -0,0 +1,2 @@
+import renderApp from './entries/client/render.js';
+export { renderApp };

package/lib/esm/core/config/index.js

@@ -0,0 +1,3 @@
+import { defineConfig } from './utils/define-config.js';
+import { resolvePath } from './utils/path.js';
+export { defineConfig, resolvePath };

package/lib/esm/core/config/type.js

@@ -0,0 +1,6 @@
+export {};
+// export type ConfigOptions = {
+//   mode: 'development' | 'production' | 'test';
+//   command: 'serve' | 'build';
+//   isSsrBuild?: boolean;
+// };

package/lib/esm/core/config/utils/define-config.js

@@ -0,0 +1,78 @@
+/**
+ * Function to define the config for the app
+ * It will be used by vite.config.ts and other files in other to configure the app
+ * @param {AppConfig | AppConfigFunction | AppConfigFunctionAsync} loadedConfig
+ */
+export const defineConfig = async (loadedConfig) => {
+    return async () => {
+        let config;
+        // Check if the loadedConfig is a function
+        if (typeof loadedConfig === 'function') {
+            // Call the function to get the config
+            const result = loadedConfig();
+            // Check if it's a promise (asynchronous function)
+            if (result instanceof Promise) {
+                config = await result; // Await the promise result (AppConfigFunctionAsync)
+            }
+            else {
+                config = result; // Synchronous function result (AppConfigFunction)
+            }
+        }
+        else {
+            config = loadedConfig;
+        }
+        const { server, vite, redirects } = config;
+        // Define default values for vite config coming from loadedConfig.vite
+        const defaultViteConfig = {
+            ...vite,
+            resolve: {
+                symbole: vite?.resolve?.symbole || '@',
+                alias: vite?.resolve?.alias || [],
+            },
+        };
+        // Define default values for server config coming from loadedConfig.server
+        const defaultServerConfig = {
+            development: {
+                port: server?.development?.port || undefined,
+                open: server?.development?.open || false,
+            },
+        };
+        // Define default values for redirects config coming from loadedConfig.redirects
+        const defaultRedirectsConfig = redirects || (() => new Promise((resolve) => resolve([])));
+        try {
+            const config = {
+                server: defaultServerConfig,
+                vite: {
+                    ...defaultViteConfig,
+                    resolve: {
+                        alias: [
+                            {
+                                find: defaultViteConfig.resolve.symbole,
+                                replacement: './src',
+                            },
+                            ...defaultViteConfig.resolve.alias,
+                        ],
+                    },
+                },
+                redirects: defaultRedirectsConfig,
+            };
+            return config;
+        }
+        catch (error) {
+            return {
+                vite: {
+                    appType: 'custom',
+                    resolve: {
+                        alias: [
+                            {
+                                find: '@',
+                                replacement: './src',
+                            },
+                        ],
+                    },
+                },
+                redirects: () => new Promise((resolve) => resolve([])),
+            };
+        }
+    };
+};

package/lib/esm/core/config/utils/load-modules.js

@@ -0,0 +1,78 @@
+import { resolvePath } from './path.js';
+import fs from 'fs/promises';
+export const extensions = [
+    '.mjs',
+    '.js',
+    '.mts',
+    '.ts',
+    '.jsx',
+    '.tsx',
+    '.json',
+];
+/**
+ * Asynchronously loads a module from a file path only in the server-side environment.
+ *
+ * @param path - The path to the module.
+ * @returns The loaded module.
+ */
+export const loadModuleSSR = async (path) => {
+    try {
+        let modulePath = path;
+        // Check if the module path has an extension
+        const moduleExtension = path.split('.').pop(); // eg: js or ts
+        if (!moduleExtension || !extensions.includes(`.${moduleExtension}`)) {
+            const { path: newPath } = await findModulePath(path);
+            modulePath = newPath;
+        }
+        const module = await import(/* @vite-ignore */ resolvePath(modulePath));
+        return module;
+    }
+    catch (error) {
+        throw new Error(error);
+    }
+};
+/**
+ * Finds the module path with the right extension.
+ *
+ * @param path - The path to the module.
+ * @returns The module path and extension.
+ */
+export const findModulePath = async (path) => {
+    try {
+        let modulePath = path;
+        let rightExtension = '';
+        // Check if the module path has an extension
+        const moduleExtension = path.split('.').pop(); // eg: js or ts
+        if (!moduleExtension || !extensions.includes(`.${moduleExtension}`)) {
+            for (let ext of extensions) {
+                const newModulePath = `${modulePath}${ext}`;
+                try {
+                    await fs.access(newModulePath);
+                    modulePath = newModulePath;
+                    rightExtension = ext;
+                    break;
+                }
+                catch (error) {
+                    continue;
+                }
+            }
+            if (modulePath === path) {
+                throw new Error(`Module "${path}" not found`);
+            }
+        }
+        return {
+            path: modulePath,
+            extension: rightExtension,
+        };
+    }
+    catch (error) {
+        throw new Error(error);
+    }
+};
+export const getDirname = async (url) => {
+    // Load the dirname function from the path module
+    // and return the dirname of the file URL
+    const { dirname } = await import('node:path');
+    const { fileURLToPath } = await import('node:url');
+    return dirname(fileURLToPath(url));
+};

package/lib/esm/core/config/utils/path.js

@@ -0,0 +1,15 @@
+/**
+ * Adapts the provided file path to a valid URL format based on the operating system.
+ *
+ * @param path - The file path to be adapted.
+ * @returns The adapted file path in a valid URL format.
+ */
+export const resolvePath = (path) => {
+    // Check the OS
+    const isWindows = process.platform === 'win32';
+    // Adapt the path
+    if (isWindows) {
+        return `file:///${path}`;
+    }
+    return path;
+};

package/lib/esm/core/config/vite/defaults.js

@@ -0,0 +1,89 @@
+// core/config/defaults.ts
+import { join } from 'node:path';
+// Define core external packages
+const CORE_EXTERNALS = [
+// '@rasenganjs/mdx',
+// '@rasenganjs/vercel',
+// '@rasenganjs/netlify',
+];
+export const createDefaultViteConfig = (rootPath, __dirname, mode, config) => {
+    // Combine core externals with user-defined externals
+    const externals = [
+        ...CORE_EXTERNALS,
+        ...(Array.isArray(config.vite?.build?.external)
+            ? config.vite.build.external
+            : []),
+    ];
+    return {
+        ...config.vite,
+        root: rootPath,
+        build: {
+            sourcemap: mode === 'development',
+            rollupOptions: {
+                external: externals,
+                input: './src/index',
+                output: {
+                    manualChunks(id) {
+                        if (id.includes('node_modules'))
+                            return 'vendor';
+                        if (id.includes('src/components'))
+                            return 'shared-components';
+                        if (id.includes('src/app') && id.includes('.page.')) {
+                            const parts = id.split('src/app')[1]?.split('/');
+                            if (parts?.length) {
+                                const pageName = parts.pop()?.split('.')[0];
+                                return pageName ? `page-${pageName}` : undefined;
+                            }
+                        }
+                        return undefined;
+                    },
+                },
+            },
+            outDir: 'dist',
+            chunkSizeWarningLimit: 1000,
+        },
+        environments: {
+            client: {
+                build: {
+                    manifest: true,
+                    outDir: 'dist/client',
+                    rollupOptions: {
+                        input: './src/index',
+                    },
+                },
+            },
+            ssr: {
+                build: {
+                    outDir: 'dist/server',
+                    rollupOptions: {
+                        input: {
+                            'entry.server': join(__dirname, './lib/esm/entries/server/entry.server.js'),
+                            'app.router': './src/app/app.router',
+                            main: './src/main',
+                            template: './src/template',
+                            config: './rasengan.config.js',
+                        },
+                    },
+                    ssrEmitAssets: false,
+                },
+            },
+        },
+        resolve: {
+            alias: Array.isArray(config.vite?.resolve?.alias)
+                ? config.vite.resolve.alias.map(({ find, replacement }) => ({
+                    find,
+                    replacement: join(rootPath, replacement),
+                }))
+                : [],
+        },
+        builder: {
+            buildApp: async (builder) => {
+                await builder.build(builder.environments.ssr);
+                await builder.build(builder.environments.client);
+            },
+        },
+        cacheDir: '.rasengan/',
+        envPrefix: 'RASENGAN_',
+        appType: 'custom',
+    };
+};

package/lib/esm/core/dynamic/index.js

@@ -0,0 +1,21 @@
+import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
+import { Suspense, lazy } from 'react';
+/**
+ * It allows you to defer loading of Client Components,
+ * and only include them in the client bundle when they're needed
+ * @param load
+ * @param fallback
+ * @returns
+ */
+export function dynamicLoad(load, fallback = _jsx(_Fragment, {}) // Default pending UI element
+) {
+    try {
+        const LazyComponent = lazy(load);
+        // Return a functional component preserving the exact props type
+        const WrappedComponent = (props) => (_jsx(Suspense, { fallback: fallback, children: _jsx(LazyComponent, { ...props }) }));
+        return WrappedComponent;
+    }
+    catch (error) {
+        throw new Error(error);
+    }
+}

package/lib/esm/core/index.js

@@ -1 +1,2 @@
-export { Body, Scripts } from "./components/index.js";
+// export { defineConfig, resolvePath } from "./config/index.js";
+export {};

package/lib/esm/core/middlewares/index.js

@@ -0,0 +1 @@
+export * from './logger.js';

package/lib/esm/core/middlewares/logger.js

@@ -0,0 +1,6 @@
+import { logGetRequest as log } from '../utils/log.js';
+export const loggerMiddleware = (req, _, next) => {
+    const url = req.originalUrl;
+    log(url);
+    next();
+};

package/lib/esm/core/plugins/index.js

@@ -0,0 +1,116 @@
+import { resolve } from 'path';
+import fs from 'fs';
+import { loadModuleSSR } from '../config/utils/load-modules.js';
+function loadRasenganConfig() {
+    return {
+        name: 'vite-plugin-rasengan-config',
+        async config(_, { command }) {
+            if (command !== 'build')
+                return;
+            const configPath = resolve(process.cwd(), 'rasengan.config.js');
+            if (!fs.existsSync(configPath)) {
+                throw new Error(`Configuration file not found at: ${configPath}`);
+            }
+            const rasenganConfig = await (await loadModuleSSR(configPath)).default;
+            const partialConfig = {
+                server: rasenganConfig.server ?? {},
+                redirects: rasenganConfig.redirects
+                    ? await rasenganConfig.redirects()
+                    : [],
+            };
+            // Inject the configuration as a global constant
+            return {
+                define: {
+                    ['__RASENGAN_CONFIG__']: JSON.stringify(partialConfig),
+                },
+            };
+        },
+    };
+}
+function rasenganConfigPlugin() {
+    const virtualModuleId = 'virtual:rasengan-config';
+    const resolvedVirtualModuleId = '\0' + virtualModuleId;
+    return {
+        name: 'vite-plugin-rasengan-config',
+        resolveId(id) {
+            if (id === virtualModuleId) {
+                return resolvedVirtualModuleId;
+            }
+        },
+        async load(id) {
+            if (id === resolvedVirtualModuleId) {
+                // if (command !== "build") return;
+                const configPath = resolve(process.cwd(), 'rasengan.config.js');
+                if (!fs.existsSync(configPath)) {
+                    throw new Error(`Configuration file not found at: ${configPath}`);
+                }
+                const rasenganConfig = await (await loadModuleSSR(configPath)).default;
+                const partialConfig = {
+                    server: rasenganConfig.server ?? {},
+                    redirects: rasenganConfig.redirects
+                        ? await rasenganConfig.redirects()
+                        : [],
+                };
+                return `
+          export const __RASENGAN_CONFIG__ = ${JSON.stringify(partialConfig)};
+        `;
+            }
+        },
+    };
+}
+function buildOutputInformation() {
+    const virtualModuleId = 'virtual:rasengan-build-info';
+    const resolvedVirtualModuleId = '\0' + virtualModuleId;
+    return {
+        name: 'vite-plugin-rasengan-build-info',
+        resolveId(id) {
+            if (id === virtualModuleId) {
+                return resolvedVirtualModuleId;
+            }
+        },
+        async load(id) {
+            if (id === resolvedVirtualModuleId) {
+                return `
+          export const resolveBuildOptions = (buildPath) => {
+            return {
+              buildDirectory: buildPath,
+              manifestPathDirectory: 'client/.vite',
+              assetPathDirectory: 'client/assets',
+              entryServerPath: 'server/entry.server.js',
+            };
+          };
+        `;
+            }
+        },
+    };
+}
+export const Adapters = {
+    VERCEL: 'vercel',
+    DEFAULT: '',
+};
+export function rasengan({ adapter = { name: Adapters.DEFAULT, prepare: async () => { } }, }) {
+    let config = {};
+    return {
+        name: 'vite-plugin-rasengan',
+        configResolved(resolvedConfig) {
+            config = resolvedConfig;
+        },
+        async closeBundle() {
+            // We check here if the environment is client has been built because it's the 
+            // last environment to be built in the Vite build process
+            if (this.environment.name === 'client') {
+                // Preparing app for deployment
+                switch (adapter.name) {
+                    case Adapters.VERCEL: {
+                        console.log('Preparing app for deployment to Vercel');
+                        await adapter.prepare();
+                        break;
+                    }
+                    default:
+                        break;
+                }
+            }
+        },
+    };
+}
+export const plugins = [];

package/lib/esm/core/utils/log.js

@@ -0,0 +1,9 @@
+import chalk from 'chalk';
+export const logRedirection = (source, destination) => {
+    const time = new Date().toLocaleTimeString();
+    console.log(`${chalk.grey(time)} ${chalk.blue('[Rasengan]')} ${chalk.green('REDIRECT')}: ${chalk.grey(source)} ${chalk.green('->')} ${chalk.grey(destination)}`);
+};
+export const logGetRequest = (url) => {
+    const time = new Date().toLocaleTimeString();
+    console.log(`${chalk.grey(time)} ${chalk.blue('[Rasengan]')} ${chalk.green('GET')}: ${chalk.grey(url)}`);
+};

package/lib/esm/entries/client/render.js

@@ -0,0 +1,16 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { hydrateRoot } from 'react-dom/client';
+import { StrictMode } from 'react';
+import { RootComponent } from '../../routing/components/template.js';
+export default function renderApp(App, options) {
+    const root = document.getElementById('root');
+    if (!root) {
+        throw new Error('Root element not found');
+    }
+    if (options.reactStrictMode) {
+        hydrateRoot(root, _jsx(StrictMode, { children: _jsx(App, { Component: RootComponent }) }));
+    }
+    else {
+        hydrateRoot(root, _jsx(App, { Component: RootComponent }));
+    }
+}