onelaraveljs 1.0.0 → 1.1.1

package/scripts/node/compiler/utils.js

@@ -0,0 +1,203 @@
+/**
+ * Utility functions for the compiler
+ */
+
+function extractBalancedParentheses(text, startPos) {
+    /** Extract content inside balanced parentheses starting from startPos */
+    if (startPos >= text.length || text[startPos] !== '(') {
+        return [null, startPos];
+    }
+    
+    let parenCount = 0;
+    const contentStart = startPos + 1;
+    let i = startPos;
+    
+    while (i < text.length) {
+        if (text[i] === '(') {
+            parenCount += 1;
+        } else if (text[i] === ')') {
+            parenCount -= 1;
+            if (parenCount === 0) {
+                const content = text.substring(contentStart, i);
+                return [content, i + 1];
+            }
+        }
+        i += 1;
+    }
+    
+    // Unbalanced parentheses
+    return [text.substring(contentStart), text.length];
+}
+
+function formatAttrs(attrsDict) {
+    /** Format attributes dictionary to JavaScript object string */
+    return JSON.stringify(attrsDict);
+}
+
+function normalizeQuotes(expr) {
+    /** Normalize single quotes to double quotes in JSON */
+    if (!expr) {
+        return expr;
+    }
+    
+    // Replace single quotes with double quotes, but be careful with nested quotes
+    return expr.replace(/'([^']*)'/g, '"$1"');
+}
+
+function formatJsOutput(content, indentLevel = 0) {
+    /** Format JavaScript output with proper indentation */
+    const lines = content.split('\n');
+    const formattedLines = [];
+    
+    for (const line of lines) {
+        if (line.trim()) {
+            formattedLines.push('    '.repeat(indentLevel) + line.trim());
+        } else {
+            formattedLines.push('');
+        }
+    }
+    
+    return formattedLines.join('\n');
+}
+
+function 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;
+}
+
+function escapeRegex(string) {
+    /** Escape special regex characters */
+    return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+function camelCase(str) {
+    /** Convert string to camelCase */
+    return str.replace(/(?:^\w|[A-Z]|\b\w)/g, (word, index) => {
+        return index === 0 ? word.toLowerCase() : word.toUpperCase();
+    }).replace(/\s+/g, '');
+}
+
+function kebabCase(str) {
+    /** Convert string to kebab-case */
+    return str.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase();
+}
+
+function snakeCase(str) {
+    /** Convert string to snake_case */
+    return str.replace(/([a-z])([A-Z])/g, '$1_$2').toLowerCase();
+}
+
+function pascalCase(str) {
+    /** Convert string to PascalCase */
+    return str.replace(/(?:^\w|[A-Z]|\b\w)/g, (word) => {
+        return word.toUpperCase();
+    }).replace(/\s+/g, '');
+}
+
+function indent(text, level = 1, char = '    ') {
+    /** Add indentation to text */
+    const indentStr = char.repeat(level);
+    return text.split('\n').map(line => line ? indentStr + line : line).join('\n');
+}
+
+function dedent(text) {
+    /** Remove common leading whitespace from text */
+    const lines = text.split('\n');
+    const minIndent = lines
+        .filter(line => line.trim())
+        .reduce((min, line) => Math.min(min, line.match(/^\s*/)[0].length), Infinity);
+    
+    return lines.map(line => line.substring(minIndent)).join('\n');
+}
+
+function replaceAll(str, replacements, startDelim = '{', endDelim = '}') {
+    /** Replace all placeholders in string with values from object */
+    if (typeof replacements !== 'object' || replacements === null) {
+        return str;
+    }
+    
+    let result = str;
+    const regex = new RegExp(`${escapeRegex(startDelim)}([^${escapeRegex(endDelim)}]+)${escapeRegex(endDelim)}`, 'g');
+    
+    return result.replace(regex, (match, key) => {
+        const trimmedKey = key.trim();
+        return replacements.hasOwnProperty(trimmedKey) ? replacements[trimmedKey] : match;
+    });
+}
+
+function isString(value) {
+    /** Check if value is string */
+    return typeof value === 'string';
+}
+
+function isObject(value) {
+    /** Check if value is object (but not null or array) */
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+
+function isArray(value) {
+    /** Check if value is array */
+    return Array.isArray(value);
+}
+
+function isEmpty(value) {
+    /** Check if value is empty */
+    if (value === null || value === undefined) return true;
+    if (isString(value)) return value.length === 0;
+    if (isArray(value)) return value.length === 0;
+    if (isObject(value)) return Object.keys(value).length === 0;
+    return false;
+}
+
+module.exports = {
+    extractBalancedParentheses,
+    formatAttrs,
+    normalizeQuotes,
+    formatJsOutput,
+    splitByComma,
+    escapeRegex,
+    camelCase,
+    kebabCase,
+    snakeCase,
+    pascalCase,
+    indent,
+    dedent,
+    replaceAll,
+    isString,
+    isObject,
+    isArray,
+    isEmpty
+};
+

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

@@ -0,0 +1,25 @@
+/**
+ * Wrapper parser
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+class WrapperParser {
+    constructor() {
+        // No initialization needed
+    }
+
+    parseWrapperFile() {
+        /** Parse wrapper file */
+        // For now, return empty content
+        // In a real implementation, this would read and parse the wrapper file
+        return {
+            wrapperFunctionContent: '',
+            wrapperConfigContent: ''
+        };
+    }
+}
+
+module.exports = WrapperParser;
+

package/scripts/node/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "one-laravel-blade-compiler",
+  "version": "1.0.0",
+  "description": "Node.js Blade Compiler for One Laravel",
+  "main": "build.js",
+  "scripts": {
+    "build": "node build.js",
+    "build:verbose": "node build.js --verbose",
+    "test": "node test-compiler.js"
+  },
+  "dependencies": {
+    "glob": "^8.1.0"
+  },
+  "devDependencies": {},
+  "keywords": [
+    "blade",
+    "compiler",
+    "template",
+    "nodejs"
+  ],
+  "author": "One Laravel Team",
+  "license": "MIT"
+}
+

package/scripts/node/test-compiler.js

@@ -0,0 +1,52 @@
+/**
+ * Test script for Node.js Blade Compiler
+ */
+
+const BladeCompiler = require('./compiler/main-compiler');
+
+// Test Blade template
+const testBladeCode = `
+@extends('layouts.base')
+
+@section('document.body')
+<div class="container">
+    <h1>Welcome {{ $user->name }}</h1>
+    
+    @if($posts && count($posts) > 0)
+        <div class="posts">
+            @foreach($posts as $post)
+                <div class="post" @click(handlePostClick($post->id))>
+                    <h3>{{ $post->title }}</h3>
+                    <p>{{ $post->content }}</p>
+                </div>
+            @endforeach
+        </div>
+    @else
+        <p>No posts available.</p>
+    @endif
+    
+    <button @click(handleButtonClick) class="btn btn-primary">
+        Click Me
+    </button>
+</div>
+@endsection
+`;
+
+// Test the compiler
+console.log('Testing Node.js Blade Compiler...\n');
+
+try {
+    const compiler = new BladeCompiler();
+    const jsCode = compiler.compileBladeToJs(testBladeCode, 'web.test');
+    
+    console.log('✅ Compilation successful!');
+    console.log('\n=== Generated JavaScript ===');
+    console.log(jsCode);
+    
+} catch (error) {
+    console.error('❌ Compilation failed:', error.message);
+    console.error(error.stack);
+}
+
+console.log('\n=== Test completed ===');
+

package/scripts/node-run.cjs

@@ -0,0 +1,28 @@
+#!/usr/bin/env node
+
+/**
+ * Node.js Blade Compiler Runner
+ * This script can be used as a drop-in replacement for the Python compiler
+ */
+
+const path = require('path');
+const NodeBuildScript = require('./node/build');
+
+// Change to the project root directory
+process.chdir(path.join(__dirname, '..'));
+
+// Create and run the build script
+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);
+});
+

package/scripts/standardize-directories.php

@@ -0,0 +1,92 @@
+<?php
+
+/**
+ * Script Chuẩn Hóa Tên Thư Mục
+ * 
+ * Script này đổi tên các thư mục trong src/ để phù hợp với PSR-4:
+ * - core → Core
+ * - modules → Modules
+ * - contexts → Contexts
+ * - shared → Shared
+ * - support → Support
+ * - infrastructure → Infrastructure
+ */
+
+class DirectoryStandardizer
+{
+    private array $mappings = [
+        'core' => 'Core',
+        'modules' => 'Modules',
+        'contexts' => 'Contexts',
+        'shared' => 'Shared',
+        'support' => 'Support',
+        'infrastructure' => 'Infrastructure',
+    ];
+
+    private string $baseDir;
+    private int $directoriesRenamed = 0;
+    private array $errors = [];
+
+    public function __construct(string $baseDir = 'src')
+    {
+        $this->baseDir = $baseDir;
+    }
+
+    public function standardize(): void
+    {
+        echo "🚀 Bắt đầu chuẩn hóa tên thư mục...\n\n";
+
+        if (!is_dir($this->baseDir)) {
+            echo "❌ Thư mục {$this->baseDir} không tồn tại!\n";
+            return;
+        }
+
+        foreach ($this->mappings as $old => $new) {
+            $oldPath = $this->baseDir . '/' . $old;
+            $newPath = $this->baseDir . '/' . $new;
+
+            if (is_dir($oldPath)) {
+                if (is_dir($newPath)) {
+                    echo "⚠️  Thư mục {$newPath} đã tồn tại, bỏ qua {$oldPath}\n";
+                    continue;
+                }
+
+                if (rename($oldPath, $newPath)) {
+                    echo "✓ Đã đổi tên: {$old} → {$new}\n";
+                    $this->directoriesRenamed++;
+                } else {
+                    $error = "❌ Không thể đổi tên: {$oldPath} → {$newPath}";
+                    echo $error . "\n";
+                    $this->errors[] = $error;
+                }
+            } else {
+                echo "⚠️  Thư mục {$oldPath} không tồn tại, bỏ qua\n";
+            }
+        }
+
+        echo "\n✅ Hoàn thành!\n";
+        echo "📊 Thống kê:\n";
+        echo "   - Số thư mục đã đổi tên: {$this->directoriesRenamed}\n";
+        
+        if (!empty($this->errors)) {
+            echo "\n❌ Lỗi:\n";
+            foreach ($this->errors as $error) {
+                echo "   - {$error}\n";
+            }
+        }
+
+        echo "\n💡 Lưu ý: Sau khi đổi tên thư mục, cần:\n";
+        echo "   1. Cập nhật namespace trong tất cả file PHP\n";
+        echo "   2. Chạy: composer dump-autoload\n";
+        echo "   3. Cập nhật các đường dẫn trong config files\n";
+    }
+}
+
+// Chạy standardization
+if (php_sapi_name() === 'cli') {
+    $standardizer = new DirectoryStandardizer('src');
+    $standardizer->standardize();
+} else {
+    echo "Script này chỉ chạy được từ command line.\n";
+}
+

package/templates/view.module.js

@@ -0,0 +1,2 @@
+import { View } from '../app/view.js';
+import { App } from '../app/init-global.js';

package/templates/view.tpl-raw.js

@@ -0,0 +1,13 @@
+export const initTemplates = function (__SYSTEM_DATA__ = {}) {
+    let { App, View, tplData = {} } = __SYSTEM_DATA__ || {};
+    const evaluate = (fn) => {
+        try {
+            return fn();
+        } catch (error) {
+            console.error(error);
+            return '';
+        }
+    }
+
+    //allScobe
+};

package/templates/wraper.js

@@ -0,0 +1,71 @@
+function wraper() {
+    // start wrapper
+
+
+    // this is the wrapper element
+    
+    const __WRAPPER_ELEMENT__ = document.createElement('template');
+    const __REFS__ = [];
+    const self = new View.Engine(__VIEW_PATH__);
+    const __STATE__ = self.__.states;
+
+
+
+    self.setApp(App);
+
+
+    const parseRefs = (frag) => {
+        for (let i = 0; i < frag.childNodes.length; i++) {
+            const node = frag.childNodes[i];
+            __REFS__.push(node);
+        }
+    }
+    const createHtml = (template) => {
+        try {
+            __WRAPPER_ELEMENT__.innerHTML = template;
+        } catch (error) {
+            console.error(error);
+            __WRAPPER_ELEMENT__.innerHTML = '';
+        }
+        let frag = __WRAPPER_ELEMENT__.content;
+        parseRefs(frag);
+        return frag;
+    }
+    
+    /**
+     * 
+     * @param {*} value 
+     * @returns {[any, function, string]}
+     */
+    const useState = (value) => {
+        return __STATE__.__useState(value);
+    };
+    const updateRealState = (state) => {
+        __STATE__.__.updateRealState(state);
+    };
+
+    const lockUpdateRealState = () => {
+        __STATE__.__.lockUpdateRealState();
+    };
+    const updateStateByKey = (key, state) => {
+        __STATE__.__.updateStateByKey(key, state);
+    };
+
+    if(typeof $$$DATA$$$.__SSR_VIEW_ID__ !== 'undefined'){
+        delete $$$DATA$$$.__SSR_VIEW_ID__;
+    }
+
+    // end wrapper
+
+}
+const WRAPPER_CONFIG = {
+    // start wrapper config
+
+    __props__: ["__WRAPPER_ELEMENT__", "createHtml", "__REFS__", "parseRefs"],
+    __WRAPPER_ELEMENT__: __WRAPPER_ELEMENT__,
+    refs: __REFS__,
+    parseRefs: parseRefs,
+    createHtml: createHtml,
+
+    // end wrapper config
+};