onelaraveljs 1.0.0 → 1.1.1

package/scripts/node/compiler/function-generators.js

@@ -0,0 +1,239 @@
+/**
+ * Generators for functions (render, prerender, init, etc.)
+ */
+
+const { JS_FUNCTION_PREFIX, HTML_ATTR_PREFIX } = require('./config');
+
+class FunctionGenerators {
+    constructor() {
+        // No initialization needed
+    }
+
+    generateRenderFunction(templateContent, varsDeclaration, extendedView, extendsData, sectionsInfo = null, hasPrerender = false, setupScript = "", directivesLine = "") {
+        /** Generate render function */
+        const varsLine = varsDeclaration ? "    " + varsDeclaration + "\n" : "";
+        const viewIdLine = "    \n";
+        
+        // Filter out sections that are already in prerender
+        // Only filter if hasPrerender is true (meaning some sections are in prerender)
+        let filteredTemplate = templateContent;
+        if (sectionsInfo && hasPrerender) {
+            for (const section of sectionsInfo) {
+                const sectionName = section.name;
+                const useVars = section.useVars || false;
+                const preloader = section.preloader || false;
+                const sectionType = section.type || 'long';
+                
+                // Remove sections that are already in prerender
+                // Only remove static sections (not using vars) that are in prerender
+                if (!useVars) {
+                    if (sectionType === 'short') {
+                        const pattern = new RegExp(`\\$\\{${JS_FUNCTION_PREFIX}\\.section\\(['"]${sectionName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}['"],\\s*[^)]+\\)\\}`, 'g');
+                        filteredTemplate = filteredTemplate.replace(pattern, '');
+                    } else { // long section
+                        const pattern = new RegExp(`\\$\\{${JS_FUNCTION_PREFIX}\\.section\\(['"]${sectionName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}['"],\\s*\`[^\`]*\`,\\s*['"]html['"]\\)\\}`, 'gs');
+                        filteredTemplate = filteredTemplate.replace(pattern, '');
+                    }
+                }
+                // If section uses vars, keep it in render (dynamic sections)
+            }
+        }
+        
+        // No need to escape template content as it's already processed correctly
+        const filteredTemplateEscaped = filteredTemplate;
+        
+        // Add setup script but remove useState declarations if register & update mechanism exists
+        let setupLine = "";
+        if (setupScript) {
+            // Check if register & update mechanism exists (has updateStateByKey)
+            const hasRegisterUpdate = directivesLine && directivesLine.includes('updateStateByKey');
+            
+            if (hasRegisterUpdate) {
+                // If register & update mechanism exists, remove useState declarations from setup script
+                // Only remove useState declarations that have state key already registered
+                let filteredSetup = setupScript;
+                // Filter logic here if needed
+                setupLine = filteredSetup ? "    " + filteredSetup + "\n" : "";
+            } else {
+                setupLine = "    " + setupScript + "\n";
+            }
+        }
+
+        if (extendedView) {
+            const dataParam = extendsData ? ", " + extendsData : "";
+            return `function(__$spaViewData$__ = {}) {
+            ${varsLine}${directivesLine}${viewIdLine}${setupLine}    let __outputRenderedContent__ = '';
+            try {
+                __outputRenderedContent__ = \`${filteredTemplateEscaped}\`;
+            } catch(e) {
+                __outputRenderedContent__ = this.showError(e.message);
+            }
+            return ${JS_FUNCTION_PREFIX}.extendView('${extendedView}'${dataParam});
+            }`;
+        } else {
+            return `function(__$spaViewData$__ = {}) {
+            ${varsLine}${directivesLine}${viewIdLine}${setupLine}    let __outputRenderedContent__ = '';
+            try {
+                __outputRenderedContent__ = \`${filteredTemplateEscaped}\`;
+            } catch(e) {
+                __outputRenderedContent__ = this.showError(e.message);
+            }
+            return __outputRenderedContent__;
+            }`;
+        }
+    }
+
+    generateLoadServerDataFunction(varsDeclaration, setupScript = "", directivesLine = "") {
+        /** Generate loadServerData function - similar to render but without template content and return */
+        const varsLine = varsDeclaration ? "    " + varsDeclaration + "\n" : "";
+        const viewIdLine = "    \n";
+        
+        let setupLine = "";
+        if (setupScript) {
+            // Filter setup script to remove useState declarations if needed
+            const filteredSetup = setupScript;
+            setupLine = filteredSetup.trim() ? "    " + filteredSetup + "\n" : "";
+        }
+        
+        return `function(__$spaViewData$__ = {}) {
+            ${varsLine}${directivesLine}${viewIdLine}${setupLine}    // Load server data - no template content needed
+            // This function is only for loading data when view is rendered from server
+            }`;
+    }
+
+    generatePrerenderFunction(hasAwait, hasFetch, varsLine, viewIdLine, templateContent, extendedView = null, extendsData = null, sectionsInfo = null, conditionalContent = null, hasPrerender = true) {
+        /** Generate prerender function */
+        if (hasAwait || hasFetch) {
+            if (extendedView) {
+                const dataParam = extendsData ? ", " + extendsData : "";
+                return `function(__$spaViewData$__ = {}) {
+                ${varsLine}${viewIdLine}    let __outputRenderedContent__ = '';
+                try {
+                    __outputRenderedContent__ = \`<div class="${HTML_ATTR_PREFIX}preloader" ref="\${__VIEW_ID__}" data-view-name="\${__VIEW_PATH__}">\${${JS_FUNCTION_PREFIX}.text('loading')}</div>\`;
+                } catch(e) {
+                    __outputRenderedContent__ = this.showError(e.message);
+                }
+                return ${JS_FUNCTION_PREFIX}.extendView('${extendedView}'${dataParam});
+                }`;
+            } else {
+                return `function(__$spaViewData$__ = {}) {
+                ${varsLine}${viewIdLine}    let __outputRenderedContent__ = '';
+                try {
+                    __outputRenderedContent__ = \`<div class="${HTML_ATTR_PREFIX}preloader" ref="\${__VIEW_ID__}" data-view-name="\${__VIEW_PATH__}">\${${JS_FUNCTION_PREFIX}.text('loading')}</div>\`;
+                } catch(e) {
+                    __outputRenderedContent__ = this.showError(e.message);
+                }
+                return __outputRenderedContent__;
+                }`;
+            }
+        } else {
+            // No await/fetch - use conditional content or empty
+            const content = conditionalContent || '';
+            
+            if (extendedView) {
+                const dataParam = extendsData ? ", " + extendsData : "";
+                return `function(__$spaViewData$__ = {}) {
+                ${varsLine}${viewIdLine}    let __outputRenderedContent__ = '';
+                try {
+                    __outputRenderedContent__ = \`${content}\`;
+                } catch(e) {
+                    __outputRenderedContent__ = this.showError(e.message);
+                }
+                return ${JS_FUNCTION_PREFIX}.extendView('${extendedView}'${dataParam});
+                }`;
+            } else {
+                return `function(__$spaViewData$__ = {}) {
+                ${varsLine}${viewIdLine}    let __outputRenderedContent__ = '';
+                try {
+                    __outputRenderedContent__ = \`${content}\`;
+                } catch(e) {
+                    __outputRenderedContent__ = this.showError(e.message);
+                }
+                return __outputRenderedContent__;
+                }`;
+            }
+        }
+    }
+
+    generateCssFunctions(viewName, cssContent = null) {
+        /** Generate CSS functions (addCSS, removeCSS) */
+        if (cssContent && cssContent.length > 0) {
+            // Separate inline CSS and external CSS
+            const inlineCss = [];
+            const externalCss = [];
+            
+            for (const css of cssContent) {
+                if (css.startsWith('<link') || css.includes('href=')) {
+                    externalCss.push(css);
+                } else {
+                    inlineCss.push(css);
+                }
+            }
+            
+            const addCssFunction = `,
+        addCSS: function() {
+            ${inlineCss.length > 0 ? `
+            const style = document.createElement('style');
+            style.setAttribute('data-view-name', '${viewName}');
+            style.textContent = \`${inlineCss.join('\n')}\`;
+            document.head.appendChild(style);` : ''}
+            ${externalCss.length > 0 ? `
+            const existingLinks = document.querySelectorAll('link[data-view-name="${viewName}"]');
+            existingLinks.forEach(link => link.remove());
+            ${externalCss.map(css => `
+            const link = document.createElement('link');
+            link.rel = 'stylesheet';
+            link.setAttribute('data-view-name', '${viewName}');
+            link.href = '${css}';
+            document.head.appendChild(link);`).join('')}` : ''}
+        }`;
+            
+            const removeCssFunction = `,
+        removeCSS: function() {
+            const styles = document.querySelectorAll('style[data-view-name="${viewName}"]');
+            styles.forEach(style => style.remove());
+            const links = document.querySelectorAll('link[data-view-name="${viewName}"]');
+            links.forEach(link => link.remove());
+        }`;
+            
+            return addCssFunction + removeCssFunction;
+        } else {
+            return `,
+        addCSS: function() {
+            // No CSS content found in @onInit
+        },
+        removeCSS: function() {
+            const styles = document.querySelectorAll('style[data-view-name="${viewName}"]');
+            styles.forEach(style => style.remove());
+        }`;
+        }
+    }
+
+    generateInitFunction(initCode) {
+        /** Generate init function */
+        if (!initCode || !initCode.trim()) {
+            return "function(__$spaViewData$__ = {}) { }";
+        }
+        
+        return `function(__$spaViewData$__ = {}) {
+            ${initCode}
+        }`;
+    }
+
+    generateDestroyFunction() {
+        /** Generate destroy function */
+        return "function() { }";
+    }
+
+    generateWrapperFunction(wrapperContent) {
+        /** Generate wrapper function */
+        if (!wrapperContent || !wrapperContent.trim()) {
+            return "";
+        }
+        
+        return wrapperContent;
+    }
+}
+
+module.exports = FunctionGenerators;
+

package/scripts/node/compiler/loop-handlers.js

@@ -0,0 +1,45 @@
+/**
+ * Loop handlers for @foreach, @for, etc.
+ */
+
+class LoopHandlers {
+    constructor() {
+        // No initialization needed
+    }
+
+    processLoopDirective(line, stack, output) {
+        /** Process loop directives */
+        const trimmedLine = line.trim();
+        
+        if (trimmedLine.startsWith('@foreach')) {
+            stack.push(['foreach', trimmedLine]);
+            return null;
+        } else if (trimmedLine.startsWith('@endforeach')) {
+            if (stack.length > 0 && stack[stack.length - 1][0] === 'foreach') {
+                stack.pop();
+                return '}';
+            }
+        } else if (trimmedLine.startsWith('@for')) {
+            stack.push(['for', trimmedLine]);
+            return null;
+        } else if (trimmedLine.startsWith('@endfor')) {
+            if (stack.length > 0 && stack[stack.length - 1][0] === 'for') {
+                stack.pop();
+                return '}';
+            }
+        } else if (trimmedLine.startsWith('@while')) {
+            stack.push(['while', trimmedLine]);
+            return null;
+        } else if (trimmedLine.startsWith('@endwhile')) {
+            if (stack.length > 0 && stack[stack.length - 1][0] === 'while') {
+                stack.pop();
+                return '}';
+            }
+        }
+        
+        return null;
+    }
+}
+
+module.exports = LoopHandlers;
+

package/scripts/node/compiler/main-compiler.js

@@ -0,0 +1,236 @@
+/**
+ * Main compiler class that combines all modules
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { 
+    JS_FUNCTION_PREFIX, 
+    HTML_ATTR_PREFIX,
+    ViewConfig 
+} = require('./config');
+const { 
+    extractBalancedParentheses, 
+    formatAttrs, 
+    normalizeQuotes, 
+    formatJsOutput,
+    replaceAll 
+} = require('./utils');
+
+class BladeCompiler {
+    constructor() {
+        this.parsers = new (require('./parsers'))();
+        this.templateProcessor = new (require('./template-processor'))();
+        this.templateAnalyzer = new (require('./template-analyzer'))();
+        this.functionGenerators = new (require('./function-generators'))();
+        this.compilerUtils = new (require('./compiler-utils'))();
+        this.wrapperParser = new (require('./wrapper-parser'))();
+        this.registerParser = new (require('./register-parser'))();
+        this.viewConfig = new ViewConfig();
+    }
+
+    convertViewPathToFunctionName(viewPath) {
+        /** Convert view path to function name (e.g., web.demo-if -> WebDemoIf) */
+        // Split by dots and hyphens
+        const parts = viewPath.split(/[.-]/);
+        // Capitalize each part and join
+        const functionName = parts.map(part => 
+            part.charAt(0).toUpperCase() + part.slice(1)
+        ).join('');
+        return functionName;
+    }
+
+    compileBladeToJs(bladeCode, viewName) {
+        /** Main compiler function */
+        bladeCode = bladeCode.trim();
+        
+        // Reset parser states to avoid data leakage between views
+        if (typeof this.registerParser.reset === 'function') {
+            this.registerParser.reset();
+        }
+        // Note: wrapper_parser doesn't reset because data from wrapper.js doesn't change
+        
+        // Parse wrapper content
+        const { wrapperFunctionContent, wrapperConfigContent } = this.wrapperParser.parseWrapperFile();
+        
+        // Convert view path to function name
+        const functionName = this.convertViewPathToFunctionName(viewName);
+        
+        // Remove Blade comments
+        bladeCode = bladeCode.replace(/\{\{--.*?--\}\}/gs, '');
+        
+        // Check for directives
+        const hasAwait = bladeCode.includes('@await(');
+        const hasFetch = bladeCode.includes('@fetch(');
+        
+        // Parse main components
+        const { extendedView, extendsExpression, extendsData } = this.parsers.parseExtends(bladeCode);
+        const varsDeclaration = this.parsers.parseVars(bladeCode);
+        const letDeclarations = this.parsers.parseLetDirectives(bladeCode);
+        const constDeclarations = this.parsers.parseConstDirectives(bladeCode);
+        const useStateDeclarations = this.parsers.parseUseStateDirectives(bladeCode);
+        const fetchConfig = hasFetch ? this.parsers.parseFetch(bladeCode) : null;
+        const { initFunctions, cssContent } = this.parsers.parseInit(bladeCode);
+        const viewTypeData = this.parsers.parseViewType(bladeCode);
+        
+        // Parse @register directive
+        const registerContent = this.parsers.parseRegister(bladeCode);
+        const registerData = this.registerParser.parseRegisterContent(registerContent);
+        
+        // Parse @wrapper directive
+        const wrapperContent = this.parsers.parseWrapper(bladeCode);
+        
+        // Process template content
+        const { templateContent, sections } = this.templateProcessor.processTemplate(bladeCode);
+        
+        // Analyze template
+        const analysis = this.templateAnalyzer.analyzeTemplate(templateContent);
+        
+        // Determine view type
+        const viewType = viewTypeData.type || 'component';
+        
+        // Generate sections info
+        const sectionsInfo = this.compilerUtils.generateSectionsInfo(sections, analysis);
+        
+        // Generate view ID line
+        const viewIdLine = `    const __VIEW_ID__ = data.__SSR_VIEW_ID__ || ${JS_FUNCTION_PREFIX}.generateViewId();\n`;
+        
+        // Generate setup script
+        let setupScript = '';
+        if (wrapperFunctionContent) {
+            setupScript = wrapperFunctionContent;
+        }
+        
+        // Generate directives line
+        let directivesLine = '';
+        if (letDeclarations || constDeclarations || useStateDeclarations) {
+            const allDeclarations = [
+                ...(letDeclarations || []),
+                ...(constDeclarations || []),
+                ...(useStateDeclarations || [])
+            ];
+            directivesLine = '    ' + allDeclarations.join('\n    ') + '\n';
+        }
+        
+        // Generate user defined line
+        let userDefinedLine = '';
+        if (registerData && Object.keys(registerData).length > 0) {
+            userDefinedLine = `\n        userDefined: ${JSON.stringify(registerData)},\n`;
+        }
+        
+        // Generate resources line
+        let resourcesLine = '';
+        if (registerData && registerData.resources && registerData.resources.length > 0) {
+            resourcesLine = `\n        resources: ${JSON.stringify(registerData.resources)},\n`;
+        } else {
+            resourcesLine = '\n        resources: [],\n';
+        }
+        
+        // Generate render function (setup script will be added to view function instead)
+        const renderFunction = this.functionGenerators.generateRenderFunction(
+            templateContent, varsDeclaration, extendedView, extendsData, 
+            sectionsInfo, analysis.hasPrerender, '', directivesLine
+        );
+        
+        // Generate init function
+        const initCode = initFunctions ? initFunctions.join('\n    ') : '';
+        const initFunction = `function(__$spaViewData$__ = {}) { ${initCode} }`;
+        
+        // Generate prerender function (only use pure vars_declaration, no directives)
+        let prerenderVarsLine = '';
+        if (varsDeclaration) {
+            prerenderVarsLine = '    ' + varsDeclaration + '\n';
+        }
+        
+        const prerenderFunc = this.functionGenerators.generatePrerenderFunction(
+            hasAwait, hasFetch, prerenderVarsLine, viewIdLine, templateContent, 
+            extendedView, extendsData, sectionsInfo, analysis.conditionalContent, 
+            analysis.hasPrerender
+        );
+        
+        // Generate loadServerData function
+        const loadServerDataFunc = this.functionGenerators.generateLoadServerDataFunction(
+            varsDeclaration, '', directivesLine
+        );
+        
+        // CSS functions - combine CSS from @onInit and @register
+        const combinedCssContent = cssContent ? [...cssContent] : [];
+        
+        // Add CSS from @register
+        if (registerData && registerData.css) {
+            const cssData = registerData.css;
+            
+            // Add inline CSS
+            if (cssData.inline) {
+                combinedCssContent.push(cssData.inline);
+            }
+            
+            // Add external CSS links
+            if (cssData.external && cssData.external.length > 0) {
+                combinedCssContent.push(...cssData.external);
+            }
+        }
+        
+        const cssFunctions = this.functionGenerators.generateCssFunctions(viewName, combinedCssContent);
+        
+        // Generate wrapper config line
+        let wrapperConfigLine = '';
+        if (wrapperConfigContent) {
+            wrapperConfigLine = wrapperConfigContent;
+        }
+        
+        // Generate super view config
+        let superViewConfig = 'null';
+        let hasSuperView = 'false';
+        if (extendedView) {
+            superViewConfig = `'${extendedView}'`;
+            hasSuperView = 'true';
+        }
+        
+        // Generate setup script line
+        let setupScriptLine = '';
+        if (setupScript) {
+            setupScriptLine = setupScript + '\n';
+        }
+        
+        // Generate wrapper function line
+        let wrapperFunctionLine = '';
+        if (wrapperContent) {
+            wrapperFunctionLine = wrapperContent + '\n';
+        }
+        
+        // Build the return string carefully to avoid syntax errors
+        return `export function ${functionName}(data = {}) {
+    const {App, View} = data;
+    const __VIEW_PATH__ = '${viewName}';
+    const __VIEW_ID__ = data.__SSR_VIEW_ID__ || ${JS_FUNCTION_PREFIX}.generateViewId();
+    const __VIEW_TYPE__ = '${viewType}';
+${wrapperFunctionLine}
+    self.setup('${viewName}', {
+        superView: ${superViewConfig},
+        hasSuperView: ${hasSuperView},
+        viewType: '${viewType}',
+        sections: ${JSON.stringify(sectionsInfo)},
+        hasAwaitData: ${hasAwait},
+        hasFetchData: ${hasFetch},
+        fetch: ${fetchConfig ? this.compilerUtils.formatFetchConfig(fetchConfig) : 'null'},
+        data: data,
+        viewId: __VIEW_ID__,
+        path: __VIEW_PATH__,
+        usesVars: ${!!varsDeclaration},
+        hasSections: ${!!sections.length},
+        hasSectionPreload: ${sectionsInfo.some(section => section.preloader)},
+        hasPrerender: ${analysis.hasPrerender},${userDefinedLine}${resourcesLine}
+        prerender: ${prerenderFunc},
+        render: ${renderFunction},
+        loadServerData: ${loadServerDataFunc},
+        init: ${initFunction},
+        destroy: function() {},${cssFunctions}${wrapperConfigLine}
+    });
+    return self;
+        }`;
+    }
+}
+
+module.exports = BladeCompiler;
+