onelaraveljs 1.0.0 → 1.1.1

package/scripts/node/compiler/parsers.js

@@ -0,0 +1,358 @@
+/**
+ * Parsers for directives (@extends, @vars, @fetch, @onInit)
+ */
+
+const { extractBalancedParentheses } = require('./utils');
+const { phpToJs, convertPhpArrayToJson } = require('./php-converter');
+
+class DirectiveParsers {
+    constructor() {
+        // No initialization needed
+    }
+
+    _removeScriptTags(bladeCode) {
+        /** Remove JavaScript code in <script> tags to avoid processing useState in JS */
+        // Remove all content in <script> tags
+        const filteredCode = bladeCode.replace(/<script[^>]*>.*?<\/script>/gis, '');
+        return filteredCode;
+    }
+
+    parseExtends(bladeCode) {
+        /** Parse @extends directive */
+        const extendsMatch = bladeCode.match(/@extends\s*\(\s*([^)]+)\s*\)/s);
+        if (!extendsMatch) {
+            return { extendedView: null, extendsExpression: null, extendsData: null };
+        }
+            
+        let extendsContent = extendsMatch[1].trim();
+        
+        // Check if there's a comma (indicating data parameter)
+        const commaPos = extendsContent.indexOf(',');
+        let viewExpr, dataExpr, extendsData;
+        
+        if (commaPos !== -1) {
+            viewExpr = extendsContent.substring(0, commaPos).trim();
+            dataExpr = extendsContent.substring(commaPos + 1).trim();
+            extendsData = this._convertExtendsData(dataExpr);
+        } else {
+            viewExpr = extendsContent;
+            extendsData = null;
+        }
+        
+        // Check if it's a simple string literal (avoid $ issues)
+        const dollarChar = '$';
+        let extendedView, extendsExpression;
+        
+        if ((viewExpr.startsWith('"') && viewExpr.endsWith('"') && !viewExpr.includes(dollarChar)) || 
+            (viewExpr.startsWith("'") && viewExpr.endsWith("'") && !viewExpr.includes(dollarChar))) {
+            extendedView = viewExpr.slice(1, -1); // Remove quotes
+            extendsExpression = null;
+        } else {
+            // Complex expression - need to evaluate at runtime
+            if (viewExpr.startsWith('"') && viewExpr.endsWith('"')) {
+                const innerContent = viewExpr.slice(1, -1);
+                const processedContent = innerContent.replace(/\$(\w+)/g, '${$1}');
+                extendsExpression = "`" + processedContent + "`";
+            } else {
+                extendsExpression = phpToJs(viewExpr);
+            }
+            extendedView = null;
+        }
+        
+        return { extendedView, extendsExpression, extendsData };
+    }
+
+    parseVars(bladeCode) {
+        /** Parse @vars directive - improved to handle complex arrays like Event directive */
+        const varsMatch = bladeCode.match(/@vars\s*\(\s*(.*?)\s*\)/s);
+        if (!varsMatch) {
+            return '';
+        }
+            
+        const varsContent = varsMatch[1];
+        const varParts = [];
+        
+        // Special handling for object destructuring syntax {var1, var2}
+        const trimmedContent = varsContent.trim();
+        let parts;
+        
+        if (trimmedContent.startsWith('{') && trimmedContent.endsWith('}')) {
+            // Extract content inside braces
+            const innerContent = trimmedContent.slice(1, -1);
+            // Split by comma at level 0
+            parts = this._splitVarsContentCorrect(innerContent);
+        } else {
+            // Use improved splitting logic (same as Event directive)
+            parts = this._splitVarsContentCorrect(varsContent);
+        }
+        
+        for (const varItem of parts) {
+            const varStr = varItem.trim();
+            if (varStr.includes('=')) {
+                const equalsPos = this._findFirstEquals(varStr);
+                if (equalsPos !== -1) {
+                    const varName = varStr.substring(0, equalsPos).trim().replace(/^\$/, '');
+                    const varValue = varStr.substring(equalsPos + 1).trim();
+                    // Convert PHP array syntax to JavaScript
+                    const convertedValue = this._convertPhpToJs(varValue);
+                    varParts.push(`${varName} = ${convertedValue}`);
+                } else {
+                    const varName = varStr.trim().replace(/^\$/, '');
+                    varParts.push(varName);
+                }
+            } else {
+                const varName = varStr.trim().replace(/^\$/, '');
+                varParts.push(varName);
+            }
+        }
+        
+        return `let {${varParts.join(', ')}} = $$$DATA$$$ || {};`;
+    }
+
+    parseLetDirectives(bladeCode) {
+        /** Parse @let directives - only process Blade directives, not JavaScript code */
+        // Remove JavaScript code in <script> tags before parsing
+        const bladeCodeFiltered = this._removeScriptTags(bladeCode);
+        
+        // Use balanced parentheses to parse correctly
+        const letMatches = [];
+        const letPattern = /@let\s*\(/g;
+        let match;
+        
+        while ((match = letPattern.exec(bladeCodeFiltered)) !== null) {
+            const startPos = match.index + match[0].length - 1; // Position of opening parenthesis
+            const [content, endPos] = extractBalancedParentheses(bladeCodeFiltered, startPos);
+            
+            if (content !== null) {
+                letMatches.push(content);
+            }
+        }
+        
+        const letDeclarations = [];
+        for (const match of letMatches) {
+            const parts = this._splitVarsContentCorrect(match);
+            for (const part of parts) {
+                const trimmedPart = part.trim();
+                if (trimmedPart) {
+                    letDeclarations.push(`let ${trimmedPart};`);
+                }
+            }
+        }
+        
+        return letDeclarations;
+    }
+
+    parseConstDirectives(bladeCode) {
+        /** Parse @const directives */
+        const constMatches = [];
+        const constPattern = /@const\s*\(/g;
+        let match;
+        
+        while ((match = constPattern.exec(bladeCode)) !== null) {
+            const startPos = match.index + match[0].length - 1;
+            const [content, endPos] = extractBalancedParentheses(bladeCode, startPos);
+            
+            if (content !== null) {
+                constMatches.push(content);
+            }
+        }
+        
+        const constDeclarations = [];
+        for (const match of constMatches) {
+            const parts = this._splitVarsContentCorrect(match);
+            for (const part of parts) {
+                const trimmedPart = part.trim();
+                if (trimmedPart) {
+                    constDeclarations.push(`const ${trimmedPart};`);
+                }
+            }
+        }
+        
+        return constDeclarations;
+    }
+
+    parseUseStateDirectives(bladeCode) {
+        /** Parse @useState directives */
+        const useStateMatches = [];
+        const useStatePattern = /@useState\s*\(/g;
+        let match;
+        
+        while ((match = useStatePattern.exec(bladeCode)) !== null) {
+            const startPos = match.index + match[0].length - 1;
+            const [content, endPos] = extractBalancedParentheses(bladeCode, startPos);
+            
+            if (content !== null) {
+                useStateMatches.push(content);
+            }
+        }
+        
+        const useStateDeclarations = [];
+        for (const match of useStateMatches) {
+            const parts = this._splitVarsContentCorrect(match);
+            for (const part of parts) {
+                const trimmedPart = part.trim();
+                if (trimmedPart) {
+                    useStateDeclarations.push(`const [${trimmedPart}] = this.useState(${trimmedPart} || null);`);
+                }
+            }
+        }
+        
+        return useStateDeclarations;
+    }
+
+    parseFetch(bladeCode) {
+        /** Parse @fetch directive */
+        const fetchMatch = bladeCode.match(/@fetch\s*\(\s*(.*?)\s*\)/s);
+        if (!fetchMatch) {
+            return null;
+        }
+        
+        const fetchContent = fetchMatch[1];
+        try {
+            // Try to parse as JSON first
+            return JSON.parse(fetchContent);
+        } catch (e) {
+            // If not valid JSON, treat as JavaScript expression
+            return fetchContent;
+        }
+    }
+
+    parseInit(bladeCode) {
+        /** Parse @onInit directive */
+        const initMatches = [];
+        const initPattern = /@onInit\s*\(\s*(.*?)\s*\)/gs;
+        let match;
+        
+        while ((match = initPattern.exec(bladeCode)) !== null) {
+            initMatches.push(match[1]);
+        }
+        
+        const initFunctions = [];
+        const cssContent = [];
+        
+        for (const initContent of initMatches) {
+            // Check if it contains CSS
+            if (initContent.includes('addCSS') || initContent.includes('style')) {
+                cssContent.push(initContent);
+            } else {
+                initFunctions.push(initContent);
+            }
+        }
+        
+        return { initFunctions, cssContent };
+    }
+
+    parseViewType(bladeCode) {
+        /** Parse @viewType directive */
+        const viewTypeMatch = bladeCode.match(/@viewType\s*\(\s*([^)]+)\s*\)/);
+        if (!viewTypeMatch) {
+            return { type: 'component' };
+        }
+        
+        const viewTypeContent = viewTypeMatch[1].trim().replace(/['"]/g, '');
+        return { type: viewTypeContent };
+    }
+
+    parseRegister(bladeCode) {
+        /** Parse @register directive */
+        const registerMatch = bladeCode.match(/@register\s*\(\s*(.*?)\s*\)/s);
+        if (!registerMatch) {
+            return '';
+        }
+        
+        return registerMatch[1];
+    }
+
+    parseWrapper(bladeCode) {
+        /** Parse @wrapper directive */
+        const wrapperMatch = bladeCode.match(/@wrapper\s*\(\s*(.*?)\s*\)/s);
+        if (!wrapperMatch) {
+            return '';
+        }
+        
+        return wrapperMatch[1];
+    }
+
+    _splitVarsContentCorrect(content) {
+        /** Split content by comma, respecting nested parentheses and quotes */
+        const result = [];
+        let current = '';
+        let depth = 0;
+        let inQuotes = false;
+        let quoteChar = '';
+        
+        for (let i = 0; i < content.length; i++) {
+            const char = content[i];
+            
+            if (!inQuotes && (char === '"' || char === "'")) {
+                inQuotes = true;
+                quoteChar = char;
+            } else if (inQuotes && char === quoteChar) {
+                inQuotes = false;
+                quoteChar = '';
+            } else if (!inQuotes && char === '(') {
+                depth++;
+            } else if (!inQuotes && char === ')') {
+                depth--;
+            } else if (!inQuotes && depth === 0 && char === ',') {
+                result.push(current.trim());
+                current = '';
+                continue;
+            }
+            
+            current += char;
+        }
+        
+        if (current.trim()) {
+            result.push(current.trim());
+        }
+        
+        return result;
+    }
+
+    _findFirstEquals(str) {
+        /** Find first equals sign not inside quotes or parentheses */
+        let depth = 0;
+        let inQuotes = false;
+        let quoteChar = '';
+        
+        for (let i = 0; i < str.length; i++) {
+            const char = str[i];
+            
+            if (!inQuotes && (char === '"' || char === "'")) {
+                inQuotes = true;
+                quoteChar = char;
+            } else if (inQuotes && char === quoteChar) {
+                inQuotes = false;
+                quoteChar = '';
+            } else if (!inQuotes && char === '(') {
+                depth++;
+            } else if (!inQuotes && char === ')') {
+                depth--;
+            } else if (!inQuotes && depth === 0 && char === '=') {
+                return i;
+            }
+        }
+        
+        return -1;
+    }
+
+    _convertPhpToJs(phpCode) {
+        /** Convert PHP code to JavaScript */
+        return phpToJs(phpCode);
+    }
+
+    _convertExtendsData(dataExpr) {
+        /** Convert extends data expression */
+        if (!dataExpr) return null;
+        
+        try {
+            return JSON.parse(dataExpr);
+        } catch (e) {
+            return dataExpr;
+        }
+    }
+}
+
+module.exports = DirectiveParsers;
+

package/scripts/node/compiler/php-converter.js

@@ -0,0 +1,227 @@
+/**
+ * Convert PHP expressions to JavaScript
+ */
+
+const { JS_FUNCTION_PREFIX } = require('./config');
+const { normalizeQuotes } = require('./utils');
+
+function convertPhpArrayToJson(expr) {
+    /** Convert PHP array syntax to JSON object/array syntax */
+    if (!expr || !expr.includes('[')) {
+        return expr;
+    }
+    
+    // Find all array patterns and convert them
+    function replaceArray(match) {
+        const inner = match[1].trim();
+        if (!inner) {
+            return '[]';
+        }
+        
+        // Check if this is array access vs array literal
+        if ((("'" in inner && (inner.match(/'/g) || []).length === 2 && !inner.includes('=>')) || 
+            ('"' in inner && (inner.match(/"/g) || []).length === 2 && !inner.includes('=>')) || 
+            (inner.replace(/[_\.]/g, '').match(/^\w+$/) && !inner.includes('=>')))) {
+            return '[' + inner + ']'; // Keep as array access
+        }
+        
+        // Process array elements
+        const elements = [];
+        let currentElement = '';
+        let parenCount = 0;
+        let bracketCount = 0;
+        let inQuotes = false;
+        let quoteChar = '';
+        let i = 0;
+        
+        while (i < inner.length) {
+            const char = inner[i];
+            
+            if ((char === '"' || char === "'") && !inQuotes) {
+                inQuotes = true;
+                quoteChar = char;
+            } else if (char === quoteChar && inQuotes) {
+                inQuotes = false;
+                quoteChar = '';
+            } else if (!inQuotes) {
+                if (char === '(') {
+                    parenCount += 1;
+                } else if (char === ')') {
+                    parenCount -= 1;
+                } else if (char === '[') {
+                    bracketCount += 1;
+                } else if (char === ']') {
+                    bracketCount -= 1;
+                } else if (char === ',' && parenCount === 0 && bracketCount === 0) {
+                    elements.push(currentElement.trim());
+                    currentElement = '';
+                    i++;
+                    continue;
+                }
+            }
+            
+            currentElement += char;
+            i++;
+        }
+        
+        if (currentElement.trim()) {
+            elements.push(currentElement.trim());
+        }
+        
+        // Process each element
+        const processedElements = elements.map(element => {
+            element = element.trim();
+            
+            // Check if it's a key => value pair
+            if (element.includes('=>')) {
+                const arrowIndex = element.indexOf('=>');
+                const key = element.substring(0, arrowIndex).trim();
+                const value = element.substring(arrowIndex + 2).trim();
+                
+                // Process key
+                let processedKey = key;
+                if ((key.startsWith("'") && key.endsWith("'")) || 
+                    (key.startsWith('"') && key.endsWith('"'))) {
+                    processedKey = key; // Keep as string literal
+                } else if (key.match(/^\d+$/)) {
+                    processedKey = key; // Keep as number
+                } else {
+                    processedKey = `"${key}"`; // Convert to string
+                }
+                
+                // Process value
+                const processedValue = convertPhpArrayToJson(value);
+                
+                return `${processedKey}: ${processedValue}`;
+            } else {
+                return convertPhpArrayToJson(element);
+            }
+        });
+        
+        // Check if all elements are key-value pairs
+        const hasKeyValuePairs = elements.some(element => element.includes('=>'));
+        
+        if (hasKeyValuePairs) {
+            return `{${processedElements.join(', ')}}`;
+        } else {
+            return `[${processedElements.join(', ')}]`;
+        }
+    }
+    
+    // Replace array patterns
+    return expr.replace(/\[(.*?)\]/g, replaceArray);
+}
+
+function phpToJs(phpCode) {
+    /** Convert PHP code to JavaScript */
+    if (!phpCode) return phpCode;
+    
+    let jsCode = phpCode;
+    
+    // Convert PHP variables ($var -> var)
+    jsCode = jsCode.replace(/\$(\w+)/g, '$1');
+    
+    // Convert PHP array syntax to JavaScript
+    jsCode = convertPhpArrayToJson(jsCode);
+    
+    // Convert PHP function calls to JavaScript
+    jsCode = jsCode.replace(/App\.Helper\.(\w+)/g, `${JS_FUNCTION_PREFIX}.Helper.$1`);
+    
+    // Convert PHP string concatenation
+    jsCode = jsCode.replace(/\s*\.\s*/g, ' + ');
+    
+    // Normalize quotes
+    jsCode = normalizeQuotes(jsCode);
+    
+    return jsCode;
+}
+
+function phpToJsAdvanced(phpCode) {
+    /** Advanced PHP to JavaScript conversion */
+    if (!phpCode) return phpCode;
+    
+    let jsCode = phpCode;
+    
+    // Convert PHP variables
+    jsCode = jsCode.replace(/\$(\w+)/g, '$1');
+    
+    // Convert PHP array syntax
+    jsCode = convertPhpArrayToJson(jsCode);
+    
+    // Convert PHP operators
+    jsCode = jsCode.replace(/===/g, '===');
+    jsCode = jsCode.replace(/!==/g, '!==');
+    jsCode = jsCode.replace(/&&/g, '&&');
+    jsCode = jsCode.replace(/\|\|/g, '||');
+    
+    // Convert PHP function calls
+    jsCode = jsCode.replace(/App\.Helper\.(\w+)/g, `${JS_FUNCTION_PREFIX}.Helper.$1`);
+    jsCode = jsCode.replace(/App\.View\.(\w+)/g, `${JS_FUNCTION_PREFIX}.$1`);
+    
+    // Convert string concatenation
+    jsCode = jsCode.replace(/\s*\.\s*/g, ' + ');
+    
+    // Convert PHP null coalescing operator
+    jsCode = jsCode.replace(/\?\?/g, '||');
+    
+    // Convert PHP ternary operator
+    jsCode = jsCode.replace(/\?\s*([^:]+)\s*:\s*([^;]+)/g, '? $1 : $2');
+    
+    // Normalize quotes
+    jsCode = normalizeQuotes(jsCode);
+    
+    return jsCode;
+}
+
+function convertPhpExpression(expr) {
+    /** Convert PHP expression to JavaScript expression */
+    if (!expr) return expr;
+    
+    // Handle different types of expressions
+    if (expr.includes('[') && expr.includes(']')) {
+        // Array expression
+        return convertPhpArrayToJson(expr);
+    } else if (expr.includes('$')) {
+        // Variable expression
+        return phpToJs(expr);
+    } else {
+        // Simple expression
+        return expr;
+    }
+}
+
+function isPhpExpression(expr) {
+    /** Check if expression contains PHP syntax */
+    return expr.includes('$') || expr.includes('[') || expr.includes('=>');
+}
+
+function escapePhpString(str) {
+    /** Escape PHP string for JavaScript */
+    return str.replace(/\\/g, '\\\\')
+              .replace(/'/g, "\\'")
+              .replace(/"/g, '\\"')
+              .replace(/\n/g, '\\n')
+              .replace(/\r/g, '\\r')
+              .replace(/\t/g, '\\t');
+}
+
+function unescapePhpString(str) {
+    /** Unescape PHP string */
+    return str.replace(/\\\\/g, '\\')
+              .replace(/\\'/g, "'")
+              .replace(/\\"/g, '"')
+              .replace(/\\n/g, '\n')
+              .replace(/\\r/g, '\r')
+              .replace(/\\t/g, '\t');
+}
+
+module.exports = {
+    convertPhpArrayToJson,
+    phpToJs,
+    phpToJsAdvanced,
+    convertPhpExpression,
+    isPhpExpression,
+    escapePhpString,
+    unescapePhpString
+};
+

package/scripts/node/compiler/register-parser.js

@@ -0,0 +1,32 @@
+/**
+ * Register parser
+ */
+
+class RegisterParser {
+    constructor() {
+        this.parseRegisterContent = {};
+    }
+
+    parseRegisterContent(registerContent) {
+        /** Parse register content */
+        if (!registerContent || !registerContent.trim()) {
+            return {};
+        }
+        
+        try {
+            // Try to parse as JSON
+            return JSON.parse(registerContent);
+        } catch (e) {
+            // If not valid JSON, return empty object
+            return {};
+        }
+    }
+
+    reset() {
+        /** Reset parser state */
+        this.parseRegisterContent = {};
+    }
+}
+
+module.exports = RegisterParser;
+

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

@@ -0,0 +1,46 @@
+/**
+ * Section handlers for @section, @yield, etc.
+ */
+
+class SectionHandlers {
+    constructor() {
+        // No initialization needed
+    }
+
+    processSectionDirective(line, stack, output, sections) {
+        /** Process section directives */
+        const trimmedLine = line.trim();
+        
+        if (trimmedLine.startsWith('@section')) {
+            const match = trimmedLine.match(/@section\s*\(\s*['"]([^'"]+)['"]\s*\)/);
+            if (match) {
+                const sectionName = match[1];
+                sections.push({
+                    name: sectionName,
+                    type: 'long',
+                    preloader: false,
+                    useVars: false,
+                    script: {}
+                });
+                stack.push(['section', sectionName]);
+            }
+            return null;
+        } else if (trimmedLine.startsWith('@endsection')) {
+            if (stack.length > 0 && stack[stack.length - 1][0] === 'section') {
+                stack.pop();
+            }
+            return null;
+        } else if (trimmedLine.startsWith('@yield')) {
+            const match = trimmedLine.match(/@yield\s*\(\s*['"]([^'"]+)['"]\s*\)/);
+            if (match) {
+                const sectionName = match[1];
+                return `\${App.View.yield('${sectionName}')}`;
+            }
+        }
+        
+        return null;
+    }
+}
+
+module.exports = SectionHandlers;
+