onelaraveljs 1.0.0 → 1.1.1

package/scripts/node/build.js

@@ -0,0 +1,208 @@
+/**
+ * Node.js Build Script - Main entry point
+ */
+
+const fs = require('fs');
+const path = require('path');
+const glob = require('glob');
+const { CompilerConfig } = require('./compiler/config');
+const BladeCompiler = require('./compiler/main-compiler');
+
+class NodeBuildScript {
+    constructor() {
+        this.config = new CompilerConfig();
+        this.compiler = new BladeCompiler();
+        this.verbose = false;
+    }
+
+    async run() {
+        /** Main build function */
+        console.log('✓ Using Node.js Blade compiler');
+        console.log('Starting build script...');
+        
+        if (this.verbose) {
+            this.config.printConfig();
+        }
+        
+        const buildDirectories = this.config.get('build_directories');
+        console.log(`Build directories: ${buildDirectories.length} directories`);
+        
+        for (let i = 0; i < buildDirectories.length; i++) {
+            const dir = buildDirectories[i];
+            const dirPath = path.join(this.config.get('paths.views_input'), dir);
+            console.log(`  ${i + 1}. ${dirPath}`);
+        }
+        
+        let totalCompiled = 0;
+        let totalViews = [];
+        
+        // Build each directory
+        for (const dir of buildDirectories) {
+            const result = await this.buildDirectory(dir);
+            totalCompiled += result.compiled;
+            totalViews.push(...result.views);
+        }
+        
+        console.log('\n=== Overall Results ===');
+        console.log(`Total compiled: ${totalCompiled}/${totalCompiled} files successfully`);
+        
+        // Build individual view files
+        await this.buildIndividualViews(totalViews);
+        
+        console.log('\n✅ Node.js build completed successfully!');
+        console.log(`📦 Total views: ${totalViews.length}`);
+        console.log(`📄 Views: [${totalViews.map(v => `'${v}'`).join(', ')}]`);
+        console.log(`📁 ViewTemplate.js: ${path.join(this.config.get('paths.js_input'), 'core', 'ViewTemplate.js')}`);
+        console.log(`📁 Individual view files: ${path.join(this.config.get('paths.js_input'), 'views')}`);
+        console.log('\n💡 Next step: Run \'npm run compile\' to build main.js');
+    }
+
+    async buildDirectory(dirName) {
+        /** Build a single directory */
+        const dirPath = path.join(this.config.get('paths.views_input'), dirName);
+        
+        if (!fs.existsSync(dirPath)) {
+            console.log(`\n=== Building directory: ${dirPath} ===`);
+            console.log(`Directory not found: ${dirPath}`);
+            return { compiled: 0, views: [] };
+        }
+        
+        console.log(`\n=== Building directory: ${dirPath} ===`);
+        
+        // Find all blade files
+        const pattern = path.join(dirPath, '**/*.blade.php');
+        const files = glob.sync(pattern);
+        
+        console.log(`Found ${files.length} blade files`);
+        
+        let compiled = 0;
+        const views = [];
+        
+        for (const file of files) {
+            const relativePath = path.relative(this.config.get('paths.views_input'), file);
+            const viewName = relativePath.replace(/\.blade\.php$/, '').replace(/\//g, '.');
+            
+            try {
+                const bladeCode = fs.readFileSync(file, 'utf8');
+                const jsCode = this.compiler.compileBladeToJs(bladeCode, viewName);
+                
+                // Generate function name
+                const functionName = this.compiler.convertViewPathToFunctionName(viewName);
+                
+                console.log(`Compiling: ${file}`);
+                console.log(`  -> ${viewName} [SUCCESS]`);
+                
+                // Store for later processing
+                views.push({
+                    name: viewName,
+                    functionName: functionName,
+                    code: jsCode
+                });
+                
+                compiled++;
+            } catch (error) {
+                console.log(`Compiling: ${file}`);
+                console.log(`  -> ${viewName} [ERROR: ${error.message}]`);
+            }
+        }
+        
+        console.log(`Directory completed: ${compiled}/${files.length} files successfully`);
+        return { compiled, views };
+    }
+
+    async buildIndividualViews(views) {
+        /** Build individual view files */
+        const viewsDir = path.join(this.config.get('paths.js_input'), 'views');
+        
+        // Clean views directory
+        if (fs.existsSync(viewsDir)) {
+            const files = fs.readdirSync(viewsDir);
+            for (const file of files) {
+                if (file.endsWith('.js')) {
+                    fs.unlinkSync(path.join(viewsDir, file));
+                }
+            }
+        } else {
+            fs.mkdirSync(viewsDir, { recursive: true });
+        }
+        
+        console.log(`✓ Cleaned views directory: ${viewsDir}`);
+        
+        // Write individual view files
+        for (const view of views) {
+            const fileName = `${view.functionName}.js`;
+            const filePath = path.join(viewsDir, fileName);
+            
+            fs.writeFileSync(filePath, view.code);
+            console.log(`Created view file: ${fileName}`);
+        }
+        
+        // Build ViewTemplate.js
+        await this.buildViewTemplate(views);
+        
+        console.log(`Successfully built ViewTemplate.js: ${path.join(this.config.get('paths.js_input'), 'core', 'ViewTemplate.js')}`);
+        console.log(`ViewTemplate.js built successfully: ${path.join(this.config.get('paths.js_input'), 'core', 'ViewTemplate.js')}`);
+    }
+
+    async buildViewTemplate(views) {
+        /** Build ViewTemplate.js file */
+        const viewTemplateContent = this.generateViewTemplateContent(views);
+        const viewTemplatePath = path.join(this.config.get('paths.js_input'), 'core', 'ViewTemplate.js');
+        
+        // Ensure core directory exists
+        const coreDir = path.dirname(viewTemplatePath);
+        if (!fs.existsSync(coreDir)) {
+            fs.mkdirSync(coreDir, { recursive: true });
+        }
+        
+        fs.writeFileSync(viewTemplatePath, viewTemplateContent);
+    }
+
+    generateViewTemplateContent(views) {
+        /** Generate ViewTemplate.js content */
+        const imports = views.map(view => 
+            `import { ${view.functionName} } from '../views/${view.functionName}.js';`
+        ).join('\n');
+        
+        const viewObjects = views.map(view => 
+            `    '${view.name}': ${view.functionName}`
+        ).join(',\n');
+        
+        return `// Auto-generated ViewTemplate.js
+// Generated by Node.js Blade Compiler
+
+${imports}
+
+const ViewTemplate = {
+${viewObjects}
+};
+
+export default ViewTemplate;
+`;
+    }
+
+    setVerbose(verbose) {
+        /** Set verbose mode */
+        this.verbose = verbose;
+    }
+}
+
+// CLI interface
+if (require.main === module) {
+    const buildScript = new NodeBuildScript();
+    
+    // Parse command line arguments
+    const args = process.argv.slice(2);
+    if (args.includes('--verbose') || args.includes('-v')) {
+        buildScript.setVerbose(true);
+    }
+    
+    // Run build
+    buildScript.run().catch(error => {
+        console.error('Build failed:', error);
+        process.exit(1);
+    });
+}
+
+module.exports = NodeBuildScript;
+

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

@@ -0,0 +1,38 @@
+/**
+ * Compiler utilities
+ */
+
+class CompilerUtils {
+    constructor() {
+        // No initialization needed
+    }
+
+    generateSectionsInfo(sections, analysis) {
+        /** Generate sections info */
+        const sectionsInfo = [];
+        
+        for (const section of sections) {
+            sectionsInfo.push({
+                name: section.name,
+                type: section.type || 'long',
+                preloader: section.preloader || false,
+                useVars: section.useVars || false,
+                script: section.script || {}
+            });
+        }
+        
+        return sectionsInfo;
+    }
+
+    formatFetchConfig(fetchConfig) {
+        /** Format fetch config */
+        if (typeof fetchConfig === 'string') {
+            return fetchConfig;
+        }
+        
+        return JSON.stringify(fetchConfig);
+    }
+}
+
+module.exports = CompilerUtils;
+

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

@@ -0,0 +1,45 @@
+/**
+ * Conditional handlers for @if, @unless, etc.
+ */
+
+class ConditionalHandlers {
+    constructor() {
+        // No initialization needed
+    }
+
+    processConditionalDirective(line, stack, output) {
+        /** Process conditional directives */
+        const trimmedLine = line.trim();
+        
+        if (trimmedLine.startsWith('@if')) {
+            stack.push(['if', trimmedLine]);
+            return null;
+        } else if (trimmedLine.startsWith('@elseif')) {
+            if (stack.length > 0 && stack[stack.length - 1][0] === 'if') {
+                return '} else if (';
+            }
+        } else if (trimmedLine.startsWith('@else')) {
+            if (stack.length > 0 && stack[stack.length - 1][0] === 'if') {
+                return '} else {';
+            }
+        } else if (trimmedLine.startsWith('@endif')) {
+            if (stack.length > 0 && stack[stack.length - 1][0] === 'if') {
+                stack.pop();
+                return '}';
+            }
+        } else if (trimmedLine.startsWith('@unless')) {
+            stack.push(['unless', trimmedLine]);
+            return null;
+        } else if (trimmedLine.startsWith('@endunless')) {
+            if (stack.length > 0 && stack[stack.length - 1][0] === 'unless') {
+                stack.pop();
+                return '}';
+            }
+        }
+        
+        return null;
+    }
+}
+
+module.exports = ConditionalHandlers;
+

package/scripts/node/compiler/config.js

@@ -0,0 +1,178 @@
+const path = require('path');
+
+class CompilerConfig {
+    constructor() {
+        this.config = {
+            paths: {
+                views_input: "resources/views",
+                js_input: "resources/js/app",
+                build_output: "resources/js/build",
+                build_scopes: "resources/js/build/scopes",
+                public_static: "public/static",
+                app_output: "public/static/app",
+                scopes_output: "public/static/app/scopes"
+            },
+            files: {
+                view_templates: "view.templates.js",
+                wrapper: "wraper.js",
+                main: "main.js"
+            },
+            patterns: {
+                blade: "**/*.blade.php",
+                js: "**/*.js"
+            },
+            settings: {
+                default_scope: "web",
+                auto_create_dirs: true,
+                verbose: false
+            },
+            build_directories: [
+                "web",
+                "admin", 
+                "layouts",
+                "partials",
+                "custom",
+                "base"
+            ]
+        };
+    }
+
+    get(key) {
+        return key.split('.').reduce((obj, k) => obj && obj[k], this.config);
+    }
+
+    set(key, value) {
+        const keys = key.split('.');
+        const lastKey = keys.pop();
+        const target = keys.reduce((obj, k) => obj[k] = obj[k] || {}, this.config);
+        target[lastKey] = value;
+    }
+
+    printConfig() {
+        console.log("=============================");
+        console.log("Compiler Configuration:");
+        console.log("=============================");
+        console.log("Views input:", this.get('paths.views_input'));
+        console.log("JS input:", this.get('paths.js_input'));
+        console.log("Build output:", this.get('paths.build_output'));
+        console.log("App output:", this.get('paths.app_output'));
+        console.log("Default scope:", this.get('settings.default_scope'));
+        console.log("Auto create dirs:", this.get('settings.auto_create_dirs'));
+        console.log("Verbose:", this.get('settings.verbose'));
+        console.log("Build directories:");
+        this.get('build_directories').forEach((dir, i) => {
+            console.log(`  ${i + 1}. ${dir}`);
+        });
+        console.log("=============================");
+    }
+}
+
+// Constants for backward compatibility
+const JS_FUNCTION_PREFIX = "App.View";
+const HTML_ATTR_PREFIX = "one-";
+const SPA_YIELD_ATTR_PREFIX = "one-yield-attr";
+const SPA_YIELD_SUBSCRIBE_KEY_PREFIX = "one-yield-key";
+const SPA_YIELD_SUBSCRIBE_TARGET_PREFIX = "one-yield-target";
+const SPA_YIELD_SUBSCRIBE_ATTR_PREFIX = "one-yield-attr";
+const SPA_YIELD_CONTENT_PREFIX = "one-yield-content";
+const SPA_YIELD_CHILDREN_PREFIX = "one-yield-children";
+const APP_VIEW_NAMESPACE = "App.View";
+const APP_HELPER_NAMESPACE = "App.Helper";
+
+// View functions configuration
+class ViewConfig {
+    constructor() {
+        // View functions - all other functions go to Helper
+        this.VIEW_FUNCTIONS = [
+            // Core functions
+            'generateViewId',
+            'execute',
+            'evaluate',
+            'escString',
+            'text',
+            'templateToDom',
+            
+            // View management
+            'view',
+            'loadView',
+            'renderView',
+            'include',
+            'includeIf',
+            'extendView',
+            
+            // View lifecycle
+            'setSuperViewPath',
+            'addViewEngine',
+            'callViewEngineMounted',
+            
+            // Wrapper functions
+            'startWrapper',
+            'endWrapper',
+            'registerSubscribe',
+            'wrapAttr',
+            // Sections
+            'section',
+            'yield',
+            'yieldContent',
+            'renderSections',
+            'hasSection',
+            'getChangedSections',
+            'resetChangedSections',
+            'isChangedSection',
+            'emitChangedSections',
+            
+            // Stacks
+            'push',
+            'stack',
+            
+            // Once
+            'once',
+            
+            // Route
+            'route',
+            
+            // Events
+            'on',
+            'off',
+            'emit',
+            
+            // Initialization
+            'init',
+            'setApp',
+            'setContainer',
+            'clearOldRendering',
+            
+            // Auth & Error functions (for Blade compatibility)
+            'isAuth',
+            'can',
+            'cannot',
+            'hasError',
+            'firstError',
+            'csrfToken',
+            
+            // Loop functions (for Blade compatibility)
+            'foreach',
+            'foreachTemplate'
+        ];
+    }
+
+    isViewFunction(functionName) {
+        return this.VIEW_FUNCTIONS.includes(functionName);
+    }
+}
+
+module.exports = {
+    CompilerConfig,
+    JS_FUNCTION_PREFIX,
+    HTML_ATTR_PREFIX,
+    SPA_YIELD_ATTR_PREFIX,
+    SPA_YIELD_SUBSCRIBE_KEY_PREFIX,
+    SPA_YIELD_SUBSCRIBE_TARGET_PREFIX,
+    SPA_YIELD_SUBSCRIBE_ATTR_PREFIX,
+    SPA_YIELD_CONTENT_PREFIX,
+    SPA_YIELD_CHILDREN_PREFIX,
+    APP_VIEW_NAMESPACE,
+    APP_HELPER_NAMESPACE,
+    ViewConfig
+};
+

package/scripts/node/compiler/directive-processors.js

@@ -0,0 +1,51 @@
+/**
+ * Directive processors for various Blade directives
+ */
+
+class DirectiveProcessor {
+    constructor() {
+        // No initialization needed
+    }
+
+    processDirective(line, stack, output) {
+        /** Process various directives */
+        const trimmedLine = line.trim();
+        
+        // Handle @include
+        if (trimmedLine.startsWith('@include')) {
+            const match = trimmedLine.match(/@include\s*\(\s*['"]([^'"]+)['"]\s*\)/);
+            if (match) {
+                const viewName = match[1];
+                return `\${App.View.include('${viewName}')}`;
+            }
+        }
+        
+        // Handle @csrf
+        if (trimmedLine.startsWith('@csrf')) {
+            return `\${App.View.csrfToken()}`;
+        }
+        
+        // Handle @method
+        if (trimmedLine.startsWith('@method')) {
+            const match = trimmedLine.match(/@method\s*\(\s*['"]([^'"]+)['"]\s*\)/);
+            if (match) {
+                const method = match[1];
+                return `<input type="hidden" name="_method" value="${method}">`;
+            }
+        }
+        
+        // Handle @error
+        if (trimmedLine.startsWith('@error')) {
+            const match = trimmedLine.match(/@error\s*\(\s*['"]([^'"]+)['"]\s*\)/);
+            if (match) {
+                const field = match[1];
+                return `\${App.View.hasError('${field}') ? App.View.firstError('${field}') : ''}`;
+            }
+        }
+        
+        return null;
+    }
+}
+
+module.exports = DirectiveProcessor;
+

package/scripts/node/compiler/event-directive-processor.js

@@ -0,0 +1,182 @@
+/**
+ * Event directive processor
+ */
+
+class EventDirectiveProcessor {
+    constructor() {
+        // No initialization needed
+    }
+
+    processEventDirective(eventType, expression) {
+        /** Process event directive */
+        try {
+            // Parse expression to extract handlers
+            const handlers = this.parseEventHandlers(expression);
+            
+            if (!handlers || handlers.length === 0) {
+                return '';
+            }
+            
+            // Build event config
+            const eventConfig = this.buildEventConfig(eventType, handlers);
+            
+            // Return event config with template string wrapper
+            return `\${${eventConfig}}`;
+                   
+        } catch (error) {
+            console.error(`Event directive error: ${error.message}`);
+            return '';
+        }
+    }
+
+    parseEventHandlers(expression) {
+        /** Parse multiple event handlers from expression */
+        const handlers = [];
+        
+        // Split by comma, respecting nested parentheses
+        const handlerStrings = this.splitByComma(expression);
+        
+        for (const handlerString of handlerStrings) {
+            const trimmed = handlerString.trim();
+            if (!trimmed) {
+                continue;
+            }
+                
+            // Parse handler name and parameters
+            const handler = this.parseHandler(trimmed);
+            if (handler) {
+                handlers.push(handler);
+            }
+        }
+        
+        return handlers;
+    }
+
+    parseHandler(handlerString) {
+        /** Parse handler name and parameters */
+        const parenIndex = handlerString.indexOf('(');
+        
+        if (parenIndex === -1) {
+            // No parameters
+            return {
+                handler: handlerString.trim(),
+                params: []
+            };
+        }
+        
+        const handlerName = handlerString.substring(0, parenIndex).trim();
+        const paramsString = handlerString.substring(parenIndex + 1, handlerString.lastIndexOf(')'));
+        
+        const params = this.parseHandlerParameters(paramsString);
+        
+        return {
+            handler: handlerName,
+            params: params
+        };
+    }
+
+    parseHandlerParameters(paramsString) {
+        /** Parse handler parameters */
+        if (!paramsString.trim()) {
+            return [];
+        }
+        
+        const params = this.splitByComma(paramsString);
+        const processedParams = [];
+        
+        for (const param of params) {
+            const processedParam = this.processParameter(param.trim());
+            processedParams.push(processedParam);
+        }
+        
+        return processedParams;
+    }
+
+    processParameter(param) {
+        /** Process individual parameter */
+        // Handle Event parameters in all contexts first
+        param = this.processEventInString(param);
+        
+        // Handle @attr(...) -> "#ATTR:..."
+        param = this.processAttrPropInString(param, '@attr', '#ATTR');
+        
+        // Handle @prop(...) -> "#PROP:..."
+        param = this.processAttrPropInString(param, '@prop', '#PROP');
+        
+        // Handle @val(...) -> "#VALUE:..."
+        param = this.processAttrPropInString(param, '@val', '#VALUE');
+        
+        // Handle @value(...) -> "#VALUE:..."
+        param = this.processAttrPropInString(param, '@value', '#VALUE');
+        
+        // Convert PHP array syntax to JavaScript object syntax
+        param = this.convertPhpArrayToJsObject(param);
+        
+        return param;
+    }
+
+    processEventInString(str) {
+        /** Process Event parameters */
+        return str.replace(/Event/g, '@EVENT');
+    }
+
+    processAttrPropInString(str, prefix, replacement) {
+        /** Process @attr/@prop/@val/@value parameters */
+        const regex = new RegExp(`${prefix}\\(([^)]+)\\)`, 'g');
+        return str.replace(regex, (match, content) => {
+            return `${replacement}:${content}`;
+        });
+    }
+
+    convertPhpArrayToJsObject(phpCode) {
+        /** Convert PHP array syntax to JavaScript object syntax */
+        // Simple conversion for now
+        return phpCode.replace(/\$(\w+)/g, '$1');
+    }
+
+    splitByComma(text) {
+        /** Split text by comma, respecting nested parentheses and quotes */
+        const result = [];
+        let current = '';
+        let depth = 0;
+        let inQuotes = false;
+        let quoteChar = '';
+        
+        for (let i = 0; i < text.length; i++) {
+            const char = text[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;
+    }
+
+    buildEventConfig(eventType, handlers) {
+        /** Build event config */
+        const handlersJson = JSON.stringify(handlers);
+        return `self.addEventConfig("${eventType}", ${handlersJson})`;
+    }
+}
+
+module.exports = EventDirectiveProcessor;
+