@bouygues-telecom/staticjs 0.1.11 → 0.1.14

package/_build/helpers/cachePages.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Load cache entries with error handling and auto-generation
+ * @param projectDir - The template directory path (e.g., "templates/react")
+ * @param verbose
+ * @returns The loaded or generated cache entries object
+ */
+export declare const loadCacheEntries: (projectDir: string, verbose?: boolean) => any;
+/**
+ * CLI wrapper that uses the modern API functions
+ * @param templateDir - Template directory (defaults to current directory for backward compatibility)
+ * @param specificFiles - Optional array of specific .tsx files to process
+ */
+export declare const runCli: (templateDir?: string, specificFiles?: string[]) => {
+    [key: string]: string;
+};

package/_build/helpers/cachePages.js

@@ -0,0 +1,162 @@
+import fs from "fs";
+import path from "path";
+import { readPages } from "./readPages.js";
+import { CONFIG } from "../server/config/index.js";
+const generateExcludedFiles = (entries) => {
+    const excludedFiles = [];
+    Object.entries(entries).forEach(([name, path]) => {
+        const content = fs.readFileSync(path, "utf8");
+        const firstLine = content.split("\n")[0];
+        if (firstLine.includes("no scripts")) {
+            delete entries[name];
+            excludedFiles.push(name);
+            // File excluded from build due to "no scripts" directive
+        }
+    });
+    try {
+        const cacheDir = path.resolve(process.cwd(), CONFIG.BUILD_DIR, "cache");
+        const excludedFilePath = path.resolve(cacheDir, "excludedFiles.json");
+        if (!fs.existsSync(cacheDir)) {
+            fs.mkdirSync(cacheDir, { recursive: true });
+        }
+        fs.writeFileSync(excludedFilePath, JSON.stringify(excludedFiles, null, 2), "utf8");
+    }
+    catch (error) {
+        console.error("Error generating excluded files:", error);
+        throw error; // Re-throw to handle it in the caller
+    }
+};
+/**
+ * Generate cache entries for a given template directory
+ * @param projectDir - The template directory path (e.g., "templates/react")
+ * @param verbose
+ * @returns The generated cache entries object
+ */
+const generateCacheEntries = (projectDir, verbose = false) => {
+    const pagesDir = path.resolve(projectDir, "src/pages");
+    const cacheDir = path.resolve(projectDir, CONFIG.BUILD_DIR, "cache");
+    const cacheFilePath = path.resolve(cacheDir, "pagesCache.json");
+    // Generating pages cache (silent unless error)
+    // Check if pages directory exists
+    if (!fs.existsSync(pagesDir)) {
+        if (verbose) {
+            console.warn(`Pages directory not found: ${pagesDir}`);
+        }
+        return {};
+    }
+    // Scan for page files using existing helper
+    const entries = readPages(pagesDir);
+    // Create cache directory if it doesn't exist
+    if (!fs.existsSync(cacheDir)) {
+        fs.mkdirSync(cacheDir, { recursive: true });
+        if (verbose) {
+            console.log(`   Created cache directory: ${cacheDir}`);
+        }
+    }
+    // Write cache file
+    fs.writeFileSync(cacheFilePath, JSON.stringify(entries, null, 2), "utf8");
+    generateExcludedFiles(entries);
+    if (verbose) {
+        console.log(`   Generated cache file: ${cacheFilePath}`);
+        console.log(`   Found ${Object.keys(entries).length} page(s)\n`);
+    }
+    return entries;
+};
+/**
+ * Load cache entries with error handling and auto-generation
+ * @param projectDir - The template directory path (e.g., "templates/react")
+ * @param verbose
+ * @returns The loaded or generated cache entries object
+ */
+export const loadCacheEntries = (projectDir, verbose = false) => {
+    const cacheFilePath = path.resolve(projectDir, CONFIG.BUILD_DIR, "cache/pagesCache.json");
+    try {
+        if (!fs.existsSync(cacheFilePath)) {
+            if (verbose) {
+                console.log('\n📝 Cache file not found, generating automatically...');
+            }
+            return generateCacheEntries(projectDir, verbose);
+        }
+        const entries = JSON.parse(fs.readFileSync(cacheFilePath, 'utf8'));
+        if (!entries || typeof entries !== 'object') {
+            if (verbose) {
+                console.log('\n📝 Invalid cache file format, regenerating...');
+            }
+            return generateCacheEntries(projectDir, verbose);
+        }
+        if (verbose) {
+            console.log(`\n✅ Loaded ${Object.keys(entries).length} cached page(s)`);
+        }
+        return entries;
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        console.error('\n❌ StaticJS Cache Error:');
+        console.error(`   ${errorMessage}`);
+        console.log('\n📝 Attempting to generate cache automatically...');
+        try {
+            return generateCacheEntries(projectDir, verbose);
+        }
+        catch (generateError) {
+            const generateErrorMessage = generateError instanceof Error ? generateError.message : String(generateError);
+            console.error('\n❌ Failed to generate cache automatically:');
+            console.error(`   ${generateErrorMessage}`);
+            console.error('\n💡 To fix this issue:');
+            console.error('   1. Run: npm run build');
+            console.error('   2. Or run: npm run dev (will auto-build if needed)');
+            console.error('   3. Or run: npm run validate-setup\n');
+            // Return empty object to prevent Vite from crashing
+            return {};
+        }
+    }
+};
+/**
+ * Process CLI arguments to generate specific page entries
+ * @param args - Command line arguments
+ * @param pagesDir - Pages directory path
+ * @returns Processed entries object
+ */
+const processCliArgs = (args, pagesDir) => {
+    return args
+        .filter((arg) => arg.endsWith(".tsx"))
+        .reduce((obj, tsxFile) => {
+        console.log(`Processing arg: ${tsxFile}`);
+        const relativePathWithoutExtension = tsxFile.replace(/\.tsx$/, "");
+        const fullPath = path.resolve(pagesDir, tsxFile);
+        obj[relativePathWithoutExtension] = fullPath;
+        return obj;
+    }, {});
+};
+/**
+ * CLI wrapper that uses the modern API functions
+ * @param templateDir - Template directory (defaults to current directory for backward compatibility)
+ * @param specificFiles - Optional array of specific .tsx files to process
+ */
+export const runCli = (templateDir = ".", specificFiles) => {
+    const args = specificFiles || process.argv.slice(2);
+    if (args.length > 0) {
+        // Handle specific files by temporarily overriding readPages behavior
+        const pagesDir = path.resolve(process.cwd(), templateDir, "src/pages");
+        const entries = processCliArgs(args, pagesDir);
+        // Use generateCacheEntries but with custom entries
+        const cacheDir = path.resolve(process.cwd(), templateDir, CONFIG.BUILD_DIR, "cache");
+        const cacheFilePath = path.resolve(cacheDir, "pagesCache.json");
+        if (!fs.existsSync(cacheDir)) {
+            fs.mkdirSync(cacheDir, { recursive: true });
+        }
+        fs.writeFileSync(cacheFilePath, JSON.stringify(entries, null, 2), "utf8");
+        console.log("Pages cached successfully.");
+        return entries;
+    }
+    else {
+        // Use the modern API for full directory scanning
+        return generateCacheEntries(templateDir, true);
+    }
+};
+// Legacy CLI support - maintain backward compatibility
+// Only run CLI logic if this file is executed directly (not imported)
+// Check if this is the main module using import.meta.url
+const isMainModule = import.meta.url === `file://${process.argv[1]}`;
+if (isMainModule) {
+    runCli();
+}

package/_build/helpers/createPage.d.ts

@@ -0,0 +1,18 @@
+import React from "react";
+interface IcreatePage {
+    data: any;
+    AppComponent: React.FC<{
+        Component: React.FC;
+        props: {};
+        pageData?: any;
+    }>;
+    PageComponent: () => React.JSX.Element;
+    initialDatasId: string;
+    rootId: string;
+    pageName: string;
+    JSfileName: string | false;
+    returnHtml?: boolean;
+    pageData?: any;
+}
+export declare const createPage: ({ data, AppComponent, PageComponent, initialDatasId, rootId, pageName, JSfileName, returnHtml, pageData, }: IcreatePage) => Promise<string | void>;
+export {};

package/_build/helpers/createPage.js

@@ -0,0 +1,41 @@
+import fs from "fs";
+import path from "path";
+import React from "react";
+import ReactDOMServer from "react-dom/server";
+import { CONFIG } from "../server/config/index.js";
+export const createPage = async ({ data, AppComponent, PageComponent, initialDatasId, rootId, pageName, JSfileName, returnHtml = false, // Default to false for backward compatibility
+pageData = {}, // Default to empty object
+ }) => {
+    const template = `{{html}}
+${data ? `<script id=initial-data-{{initialDatasId}} type="application/json">${JSON.stringify(data)}</script>` : ""}
+${JSfileName ? `<script type="module" src="{{scriptPath}}"></script>` : ""}
+`;
+    // Create a wrapper component that adds the app div around the page component
+    const PageWithAppDiv = (props) => {
+        return React.createElement('div', { id: `app-${rootId}` }, React.createElement(PageComponent, props));
+    };
+    const component = React.createElement(AppComponent, {
+        Component: PageWithAppDiv,
+        props: { data },
+        pageData, // Pass pageData to AppComponent
+    });
+    const htmlContent = template
+        .replace("{{initialDatasId}}", initialDatasId)
+        .replace("{{html}}", ReactDOMServer.renderToString(component))
+        .replace("{{scriptPath}}", `/${pageName}.js`);
+    // Return HTML string for runtime rendering or write to file for build time
+    if (returnHtml) {
+        return htmlContent;
+    }
+    else {
+        // If page name contains a slash, create directories
+        const pageNameParts = pageName.split("/");
+        if (pageNameParts.length > 1) {
+            const dirPath = path.join(CONFIG.PROJECT_ROOT, CONFIG.BUILD_DIR, ...pageNameParts.slice(0, -1));
+            if (!fs.existsSync(dirPath)) {
+                fs.mkdirSync(dirPath, { recursive: true });
+            }
+        }
+        fs.writeFileSync(path.join(CONFIG.PROJECT_ROOT, CONFIG.BUILD_DIR, `${pageName}.html`), htmlContent);
+    }
+};

package/_build/helpers/layoutDiscovery.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Discovers the closest layout.tsx file by walking up the directory tree
+ * from the given page path
+ */
+export declare function findClosestLayout(pagePath: string, rootDir: string): string | null;
+/**
+ * Gets the relative path from rootDir for layout identification
+ */
+export declare function getLayoutIdentifier(layoutPath: string, rootDir: string): string;

package/_build/helpers/layoutDiscovery.js

@@ -0,0 +1,39 @@
+import fs from "fs";
+import path from "path";
+/**
+ * Discovers the closest layout.tsx file by walking up the directory tree
+ * from the given page path
+ */
+export function findClosestLayout(pagePath, rootDir) {
+    // Get the directory containing the page
+    const pageDir = path.dirname(pagePath);
+    // Start from the page's directory and walk up
+    let currentDir = pageDir;
+    while (true) {
+        // Check if layout.tsx exists in current directory
+        const layoutPath = path.join(currentDir, "layout.tsx");
+        if (fs.existsSync(layoutPath)) {
+            return layoutPath;
+        }
+        // Get parent directory
+        const parentDir = path.dirname(currentDir);
+        // If we've reached the root directory or can't go up further, stop
+        if (parentDir === currentDir || !currentDir.startsWith(rootDir)) {
+            break;
+        }
+        currentDir = parentDir;
+    }
+    // Fallback to global layout if no layout.tsx found in the hierarchy
+    const globalLayoutPath = path.join(rootDir, "layout.tsx");
+    if (fs.existsSync(globalLayoutPath)) {
+        return globalLayoutPath;
+    }
+    return null;
+}
+/**
+ * Gets the relative path from rootDir for layout identification
+ */
+export function getLayoutIdentifier(layoutPath, rootDir) {
+    const relativePath = path.relative(rootDir, layoutPath);
+    return relativePath.replace(/\.tsx$/, "");
+}

package/_build/helpers/readPages.d.ts

@@ -0,0 +1,3 @@
+export declare function readPages(dir: string, baseDir?: string): {
+    [key: string]: string;
+};

package/_build/helpers/readPages.js

@@ -0,0 +1,24 @@
+import fs from "fs";
+import path from "path";
+export function readPages(dir, baseDir = dir) {
+    let result = {};
+    const files = fs.readdirSync(dir);
+    for (const file of files) {
+        const fullPath = path.join(dir, file);
+        const stat = fs.statSync(fullPath);
+        if (stat.isDirectory()) {
+            // Check if this directory contains an index.tsx file
+            const indexPath = path.join(fullPath, "index.tsx");
+            if (fs.existsSync(indexPath)) {
+                // Create route path from folder structure
+                const relPath = path.relative(baseDir, fullPath);
+                result[relPath] = indexPath;
+            }
+            // Continue recursively searching for more pages
+            const nested = readPages(fullPath, baseDir);
+            result = { ...result, ...nested };
+        }
+        // Note: Direct .tsx files are no longer supported - only folder-based routes with index.tsx
+    }
+    return result;
+}

package/_build/helpers/renderPageRuntime.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Runtime page rendering function that uses the same logic as build-html.ts
+ * but returns HTML string instead of writing to file
+ */
+export declare function renderPageRuntime(requestPath: string, params?: {
+    [key: string]: string;
+}): Promise<string | null>;
+/**
+ * Get all available pages for development mode
+ */
+export declare function getAvailablePagesRuntime(): {
+    [key: string]: string;
+};

package/_build/helpers/renderPageRuntime.js

@@ -0,0 +1,222 @@
+process.env.NODE_TLS_REJECT_UNAUTHORIZED = "0";
+import fs from "fs/promises";
+import crypto from "node:crypto";
+import path from "path";
+import React from "react";
+import { createPage } from "./createPage.js";
+import { readPages } from "./readPages.js";
+import { CONFIG } from "../server/config/index.js";
+import { findClosestLayout } from "./layoutDiscovery.js";
+const rootDir = path.resolve(process.cwd(), "./src");
+async function loadJson(filePath) {
+    try {
+        const data = await fs.readFile(filePath, "utf-8");
+        return JSON.parse(data);
+    }
+    catch (error) {
+        // Return empty object if file doesn't exist (for development mode)
+        return {};
+    }
+}
+/**
+ * Runtime page rendering function that uses the same logic as build-html.ts
+ * but returns HTML string instead of writing to file
+ */
+export async function renderPageRuntime(requestPath, params) {
+    try {
+        // Load excluded files for "no scripts" functionality
+        const excludedJSFiles = await loadJson(path.join(process.cwd(), `./${CONFIG.BUILD_DIR}/cache/excludedFiles.json`));
+        // Get available pages using readPages helper
+        const pagesDir = path.resolve(process.cwd(), "src/pages");
+        const pages = readPages(pagesDir);
+        // Find the matching page
+        let matchedPage = null;
+        let matchedParams = {};
+        // Handle root path
+        if (requestPath === "/" || requestPath === "") {
+            if (pages["index"]) {
+                matchedPage = { path: pages["index"], pageName: "index" };
+            }
+        }
+        else {
+            // Remove leading slash and try exact match first
+            const cleanPath = requestPath.replace(/^\//, "");
+            // Try exact match first
+            if (pages[cleanPath]) {
+                matchedPage = { path: pages[cleanPath], pageName: cleanPath };
+            }
+            else {
+                // Try to match with different prefixes (for flexibility)
+                const possiblePaths = [
+                    cleanPath,
+                    `partials/${cleanPath}`,
+                    cleanPath.replace(/^partials\//, "")
+                ];
+                for (const testPath of possiblePaths) {
+                    if (pages[testPath]) {
+                        matchedPage = { path: pages[testPath], pageName: testPath };
+                        break;
+                    }
+                }
+                // If still no match, try dynamic routes
+                if (!matchedPage) {
+                    for (const [pageName, pagePath] of Object.entries(pages)) {
+                        if (pageName.includes("[") && pageName.includes("]")) {
+                            // Extract the dynamic parameter name
+                            const paramMatch = pageName.match(/\[([^\]]+)\]/);
+                            if (paramMatch) {
+                                const paramName = paramMatch[1];
+                                // Try matching against multiple possible paths
+                                for (const testPath of possiblePaths) {
+                                    // Create a regex pattern from the page name
+                                    const regexPattern = pageName.replace(/\[([^\]]+)\]/g, '([^/]+)');
+                                    const regex = new RegExp(`^${regexPattern}$`);
+                                    const match = testPath.match(regex);
+                                    if (match) {
+                                        // Extract the parameter value from the matched groups
+                                        const paramValue = match[1];
+                                        if (paramValue) {
+                                            matchedPage = { path: pagePath, pageName: testPath };
+                                            matchedParams[paramName] = paramValue;
+                                            break;
+                                        }
+                                    }
+                                }
+                                if (matchedPage)
+                                    break;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        if (!matchedPage) {
+            return null; // Page not found
+        }
+        return await processPageRuntime(matchedPage, excludedJSFiles, matchedParams);
+    }
+    catch (error) {
+        console.error("Error in renderPageRuntime:", error);
+        return null;
+    }
+}
+/**
+ * Process a single page for runtime rendering (adapted from build-html.ts processPage)
+ */
+async function processPageRuntime(page, excludedJSFiles, params = {}) {
+    let data;
+    const absolutePath = page.path;
+    // Add cache busting to avoid module caching issues in development
+    const cacheBuster = `?t=${Date.now()}`;
+    try {
+        const pageModule = await import(`${absolutePath}${cacheBuster}`);
+        // Load page data.json if it exists
+        const pageDir = path.dirname(absolutePath);
+        const dataJsonPath = path.join(pageDir, 'data.json');
+        let pageData = {};
+        try {
+            const dataContent = await fs.readFile(dataJsonPath, 'utf-8');
+            pageData = JSON.parse(dataContent);
+        }
+        catch (error) {
+            // data.json doesn't exist, use empty object
+        }
+        // Discover the closest layout for this page
+        const layoutPath = findClosestLayout(absolutePath, rootDir);
+        if (!layoutPath) {
+            throw new Error(`No layout found for page ${page.pageName}`);
+        }
+        const layoutModule = await import(`${layoutPath}${cacheBuster}`);
+        const appModule = await import(`${rootDir}/app.tsx${cacheBuster}`);
+        const fileName = path.basename(page.path, path.extname(page.path));
+        // Create a dynamic App component that uses the discovered layout
+        const LayoutComponent = layoutModule.Layout;
+        if (!LayoutComponent) {
+            throw new Error(`Layout component not found in ${layoutPath}. Make sure it exports 'Layout'.`);
+        }
+        // Create a wrapper App component that uses the actual App component
+        const AppComponent = ({ Component, props }) => {
+            // Create a layout wrapper that accepts pageData
+            const LayoutWrapper = ({ children }) => {
+                return React.createElement(LayoutComponent, { pageData, children });
+            };
+            // Use the actual App component and wrap it with our layout
+            return React.createElement(LayoutWrapper, {
+                children: React.createElement(appModule.App, { Component, props, pageData })
+            });
+        };
+        const PageComponent = pageModule.default;
+        const getStaticProps = pageModule?.getStaticProps;
+        const getStaticPaths = pageModule?.getStaticPaths;
+        const injectJS = !excludedJSFiles.includes(page.pageName);
+        const rootId = crypto
+            .createHash("sha256")
+            .update(`app-${absolutePath}`)
+            .digest("hex")
+            .slice(0, 10);
+        const initialDatasId = crypto
+            .createHash("sha256")
+            .update(`initial-data-${absolutePath}`)
+            .digest("hex")
+            .slice(0, 10);
+        if (!PageComponent) {
+            throw new Error(`Failed to import PageComponent from ${page.pageName}.tsx`);
+        }
+        // Handle getStaticProps with or without dynamic params
+        if (getStaticProps) {
+            if (Object.keys(params).length > 0) {
+                // Dynamic route with params
+                const { props } = await getStaticProps({ params });
+                data = props.data;
+            }
+            else {
+                // Static route
+                const { props } = await getStaticProps();
+                data = props.data;
+            }
+        }
+        // Generate HTML using createPage helper with returnHtml flag
+        // Use dynamic import to load createPage from the template directory
+        let htmlContent;
+        try {
+            // Try to import createPage from the template's helpers directory
+            const templateCreatePagePath = path.resolve(process.cwd(), "../../helpers/createPage.js");
+            const { createPage: templateCreatePage } = await import(templateCreatePagePath);
+            htmlContent = templateCreatePage({
+                data,
+                AppComponent,
+                PageComponent,
+                initialDatasId,
+                rootId,
+                pageName: page.pageName,
+                JSfileName: injectJS && fileName,
+                returnHtml: true,
+            });
+        }
+        catch (error) {
+            // Fallback to server's createPage
+            htmlContent = await createPage({
+                data,
+                AppComponent,
+                PageComponent,
+                initialDatasId,
+                rootId,
+                pageName: page.pageName,
+                JSfileName: injectJS && fileName,
+                returnHtml: true,
+            });
+        }
+        return htmlContent;
+    }
+    catch (error) {
+        console.error(`[DEBUG] Error in processPageRuntime:`, error);
+        throw error;
+    }
+}
+/**
+ * Get all available pages for development mode
+ */
+export function getAvailablePagesRuntime() {
+    const pagesDir = path.resolve(process.cwd(), "src/pages");
+    return readPages(pagesDir);
+}

package/_build/scripts/build-html.d.ts

@@ -0,0 +1 @@
+export {};