@jetstart/core 1.6.0 → 2.0.0

package/dist/build/kotlin-compiler.js

@@ -0,0 +1,450 @@
+"use strict";
+/**
+ * Kotlin Compiler Service
+ * Compiles Kotlin files to .class files for hot reload
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KotlinCompiler = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const child_process_1 = require("child_process");
+const logger_1 = require("../utils/logger");
+class KotlinCompiler {
+    projectPath;
+    static TAG = 'KotlinCompiler';
+    kotlincPath = null;
+    composeCompilerPath = null;
+    staticClasspath = []; // SDK + deps cached; project classes always fresh
+    constructor(projectPath) {
+        this.projectPath = projectPath;
+    }
+    /**
+     * Find Compose compiler plugin JAR
+     * For Kotlin 2.0+, the Compose compiler is bundled with kotlinc
+     */
+    async findComposeCompiler() {
+        if (this.composeCompilerPath)
+            return this.composeCompilerPath;
+        // First check if kotlinc has a bundled Compose compiler (Kotlin 2.0+)
+        const kotlincPath = await this.findKotlinc();
+        if (kotlincPath) {
+            const kotlincDir = path.dirname(path.dirname(kotlincPath)); // Go up from bin/kotlinc
+            const bundledComposePlugin = path.join(kotlincDir, 'lib', 'compose-compiler-plugin.jar');
+            if (fs.existsSync(bundledComposePlugin)) {
+                this.composeCompilerPath = bundledComposePlugin;
+                (0, logger_1.log)(`Found bundled Compose compiler (Kotlin 2.0+)`);
+                return this.composeCompilerPath;
+            }
+        }
+        // Fallback to Gradle cache for older Kotlin versions
+        const gradleCache = path.join(os.homedir(), '.gradle', 'caches', 'modules-2', 'files-2.1');
+        const composeCompilerDir = path.join(gradleCache, 'androidx.compose.compiler', 'compiler');
+        if (!fs.existsSync(composeCompilerDir)) {
+            (0, logger_1.log)('Compose compiler not found');
+            return null;
+        }
+        // Find latest version
+        const versions = fs.readdirSync(composeCompilerDir)
+            .filter(v => fs.statSync(path.join(composeCompilerDir, v)).isDirectory())
+            .sort().reverse();
+        for (const version of versions) {
+            const versionDir = path.join(composeCompilerDir, version);
+            const hashes = fs.readdirSync(versionDir);
+            for (const hash of hashes) {
+                const hashDir = path.join(versionDir, hash);
+                if (!fs.statSync(hashDir).isDirectory())
+                    continue;
+                const files = fs.readdirSync(hashDir);
+                for (const file of files) {
+                    if (file.endsWith('.jar') && !file.endsWith('-sources.jar')) {
+                        this.composeCompilerPath = path.join(hashDir, file);
+                        (0, logger_1.log)(`Found Compose compiler: ${version}`);
+                        return this.composeCompilerPath;
+                    }
+                }
+            }
+        }
+        return null;
+    }
+    /**
+     * Find kotlinc executable
+     */
+    async findKotlinc() {
+        if (this.kotlincPath)
+            return this.kotlincPath;
+        // Check common locations
+        const locations = [
+            // From environment variable
+            process.env.KOTLIN_HOME ? path.join(process.env.KOTLIN_HOME, 'bin', 'kotlinc') : null,
+            // From Android Studio
+            process.env.ANDROID_STUDIO_HOME ? path.join(process.env.ANDROID_STUDIO_HOME, 'plugins', 'Kotlin', 'kotlinc', 'bin', 'kotlinc') : null,
+            // System-wide installation (Windows)
+            'C:\\Program Files\\kotlinc\\bin\\kotlinc.bat',
+            'C:\\kotlinc\\bin\\kotlinc.bat',
+            // System-wide installation (Unix)
+            '/usr/local/bin/kotlinc',
+            '/usr/bin/kotlinc',
+            // Homebrew (macOS)
+            '/opt/homebrew/bin/kotlinc',
+        ].filter(Boolean);
+        for (const loc of locations) {
+            const execPath = os.platform() === 'win32' && !loc.endsWith('.bat') ? `${loc}.bat` : loc;
+            if (fs.existsSync(execPath)) {
+                this.kotlincPath = execPath;
+                (0, logger_1.log)(`Found kotlinc at: ${execPath}`);
+                return execPath;
+            }
+        }
+        // Try to find via 'where' (Windows) or 'which' (Unix)
+        try {
+            const cmd = os.platform() === 'win32' ? 'where' : 'which';
+            const result = await this.runCommand(cmd, ['kotlinc']);
+            if (result.success && result.stdout.trim()) {
+                this.kotlincPath = result.stdout.trim().split('\n')[0];
+                (0, logger_1.log)(`Found kotlinc via ${cmd}: ${this.kotlincPath}`);
+                return this.kotlincPath;
+            }
+        }
+        catch (e) {
+            // Ignore
+        }
+        (0, logger_1.error)('kotlinc not found. Please install Kotlin or set KOTLIN_HOME');
+        return null;
+    }
+    /**
+     * Build the classpath for compilation
+     * This needs to include Android SDK, Compose, and project dependencies
+     */
+    async buildClasspath() {
+        if (this.staticClasspath.length > 0) {
+            return [...this.staticClasspath, ...this.getProjectClasspathEntries()];
+        }
+        const classpath = [];
+        // Check multiple locations for Android SDK
+        let androidHome = process.env.ANDROID_HOME || process.env.ANDROID_SDK_ROOT;
+        // Fallback to common Windows locations
+        if (!androidHome) {
+            const commonLocations = [
+                'C:\\Android',
+                path.join(os.homedir(), 'AppData', 'Local', 'Android', 'Sdk'),
+                'C:\\Users\\Public\\Android\\Sdk',
+            ];
+            for (const loc of commonLocations) {
+                if (fs.existsSync(path.join(loc, 'platforms'))) {
+                    androidHome = loc;
+                    (0, logger_1.log)(`Found Android SDK at: ${loc}`);
+                    break;
+                }
+            }
+        }
+        if (!androidHome) {
+            (0, logger_1.error)('ANDROID_HOME or ANDROID_SDK_ROOT not set');
+            return classpath;
+        }
+        // Find android.jar
+        const platformsDir = path.join(androidHome, 'platforms');
+        if (fs.existsSync(platformsDir)) {
+            const platforms = fs.readdirSync(platformsDir)
+                .filter(d => d.startsWith('android-'))
+                .sort((a, b) => {
+                const aNum = parseInt(a.replace('android-', ''));
+                const bNum = parseInt(b.replace('android-', ''));
+                return bNum - aNum;
+            });
+            if (platforms.length > 0) {
+                const androidJar = path.join(platformsDir, platforms[0], 'android.jar');
+                if (fs.existsSync(androidJar)) {
+                    classpath.push(androidJar);
+                    (0, logger_1.log)(`Using Android SDK: ${platforms[0]}`);
+                }
+            }
+        }
+        // Add ALL Gradle cached dependencies (Compose, AndroidX, Kotlin, etc.)
+        const gradleCache = path.join(os.homedir(), '.gradle', 'caches', 'modules-2', 'files-2.1');
+        if (fs.existsSync(gradleCache)) {
+            // Scan for all required dependency groups
+            const requiredGroups = [
+                'androidx.compose.runtime',
+                'androidx.compose.ui',
+                'androidx.compose.foundation',
+                'androidx.compose.material3',
+                'androidx.compose.material',
+                'androidx.compose.animation',
+                'androidx.annotation',
+                'androidx.core',
+                'androidx.activity',
+                'androidx.lifecycle',
+                'androidx.savedstate',
+                'androidx.collection',
+                'org.jetbrains.kotlin',
+                'org.jetbrains.kotlinx',
+                'org.jetbrains.annotations',
+            ];
+            for (const group of requiredGroups) {
+                const groupDir = path.join(gradleCache, group);
+                if (fs.existsSync(groupDir)) {
+                    // Get all artifacts in this group
+                    const artifacts = fs.readdirSync(groupDir);
+                    for (const artifact of artifacts) {
+                        const artifactDir = path.join(groupDir, artifact);
+                        if (!fs.statSync(artifactDir).isDirectory())
+                            continue;
+                        // Find latest version
+                        const versions = fs.readdirSync(artifactDir)
+                            .filter(v => fs.statSync(path.join(artifactDir, v)).isDirectory())
+                            .sort().reverse();
+                        if (versions.length > 0) {
+                            const versionDir = path.join(artifactDir, versions[0]);
+                            const hashes = fs.readdirSync(versionDir);
+                            for (const hash of hashes) {
+                                const hashDir = path.join(versionDir, hash);
+                                if (!fs.statSync(hashDir).isDirectory())
+                                    continue;
+                                const files = fs.readdirSync(hashDir);
+                                // Add all JARs (not sources or javadoc)
+                                for (const file of files) {
+                                    if (file.endsWith('.jar') &&
+                                        !file.endsWith('-sources.jar') &&
+                                        !file.endsWith('-javadoc.jar')) {
+                                        classpath.push(path.join(hashDir, file));
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        // Scan transforms-3 cache - grab ALL classes.jar (Compose, Material3, Room, DivKit, etc.)
+        const transformsCache = path.join(os.homedir(), '.gradle', 'caches', 'transforms-3');
+        if (fs.existsSync(transformsCache)) {
+            try {
+                for (const hash of fs.readdirSync(transformsCache)) {
+                    const transformedDir = path.join(transformsCache, hash, 'transformed');
+                    if (!fs.existsSync(transformedDir))
+                        continue;
+                    try {
+                        for (const pkg of fs.readdirSync(transformedDir)) {
+                            const classesJar = path.join(transformedDir, pkg, 'jars', 'classes.jar');
+                            if (fs.existsSync(classesJar) && !classpath.includes(classesJar)) {
+                                classpath.push(classesJar);
+                            }
+                        }
+                    }
+                    catch (e) { /* ignore */ }
+                }
+                (0, logger_1.log)(`Added ${classpath.length} transforms-3 JARs to classpath`);
+            }
+            catch (e) { /* ignore */ }
+        }
+        // Cache static entries; project build outputs always fetched fresh
+        this.staticClasspath = [...classpath];
+        const projectEntries = this.getProjectClasspathEntries();
+        (0, logger_1.log)(`Built static classpath with ${classpath.length} entries + ${projectEntries.length} project entries`);
+        return [...classpath, ...projectEntries];
+    }
+    /**
+     * Get project build output classpath entries.
+     * Always called fresh ΓÇö never cached ΓÇö so new class files from Gradle builds are always visible.
+     */
+    getProjectClasspathEntries() {
+        const entries = [];
+        const candidates = [
+            path.join(this.projectPath, 'app', 'build', 'tmp', 'kotlin-classes', 'debug'),
+            path.join(this.projectPath, 'app', 'build', 'intermediates', 'javac', 'debug', 'classes'),
+            path.join(this.projectPath, 'app', 'build', 'intermediates', 'compile_and_runtime_not_namespaced_r_class_jar', 'debug', 'R.jar'),
+            path.join(this.projectPath, 'app', 'build', 'intermediates', 'classes', 'debug', 'transformDebugClassesWithAsm', 'jars', '0.jar'),
+        ];
+        for (const c of candidates) {
+            if (fs.existsSync(c))
+                entries.push(c);
+        }
+        return entries;
+    }
+    /**
+     * Recursively find JAR files in a directory up to maxDepth
+     */
+    findJarsRecursive(dir, classpath, maxDepth, currentDepth = 0) {
+        if (currentDepth > maxDepth || !fs.existsSync(dir))
+            return;
+        try {
+            const entries = fs.readdirSync(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                const fullPath = path.join(dir, entry.name);
+                if (entry.isDirectory()) {
+                    this.findJarsRecursive(fullPath, classpath, maxDepth, currentDepth + 1);
+                }
+                else if (entry.name.endsWith('.jar') && !classpath.includes(fullPath)) {
+                    classpath.push(fullPath);
+                }
+            }
+        }
+        catch (e) {
+            // Ignore permission errors
+        }
+    }
+    /**
+     * Compile a single Kotlin file
+     */
+    async compileFile(filePath) {
+        const kotlinc = await this.findKotlinc();
+        if (!kotlinc) {
+            return {
+                success: false,
+                classFiles: [],
+                errors: ['kotlinc not found'],
+                outputDir: ''
+            };
+        }
+        const classpath = await this.buildClasspath();
+        if (classpath.length === 0) {
+            return {
+                success: false,
+                classFiles: [],
+                errors: ['Failed to build classpath - Android SDK not found'],
+                outputDir: ''
+            };
+        }
+        // Create temp output directory
+        const outputDir = path.join(os.tmpdir(), 'jetstart-compile', Date.now().toString());
+        fs.mkdirSync(outputDir, { recursive: true });
+        (0, logger_1.log)(`Compiling ${path.basename(filePath)}...`);
+        // Find Compose compiler plugin for @Composable support
+        const composeCompiler = await this.findComposeCompiler();
+        // On Windows, command line can be too long with many classpath entries
+        // Use an argument file (@argfile) to avoid this limitation
+        const classpathStr = classpath.join(os.platform() === 'win32' ? ';' : ':');
+        const argLines = [
+            `-d`,
+            outputDir,
+            `-classpath`,
+            classpathStr,
+            `-jvm-target`,
+            `17`,
+            `-Xskip-prerelease-check`,
+            `-Xno-call-assertions`,
+            `-Xno-param-assertions`,
+        ];
+        // Add Compose compiler plugin if found
+        if (composeCompiler) {
+            argLines.push(`-Xplugin=${composeCompiler}`);
+            (0, logger_1.log)(`Using Compose compiler plugin`);
+        }
+        argLines.push(filePath);
+        const argFileContent = argLines.join('\n');
+        const argFilePath = path.join(outputDir, 'kotlinc-args.txt');
+        fs.writeFileSync(argFilePath, argFileContent);
+        (0, logger_1.log)(`Using argument file: ${argFilePath}`);
+        // Build kotlinc arguments using @argfile
+        const args = [`@${argFilePath}`];
+        const result = await this.runCommand(kotlinc, args);
+        if (!result.success) {
+            return {
+                success: false,
+                classFiles: [],
+                errors: [result.stderr || 'Compilation failed'],
+                outputDir
+            };
+        }
+        // Find generated class files
+        const classFiles = this.findClassFiles(outputDir);
+        (0, logger_1.log)(`Compiled ${classFiles.length} class files`);
+        return {
+            success: true,
+            classFiles,
+            errors: [],
+            outputDir
+        };
+    }
+    /**
+     * Find all .class files in a directory
+     */
+    findClassFiles(dir) {
+        const files = [];
+        const walk = (d) => {
+            if (!fs.existsSync(d))
+                return;
+            const entries = fs.readdirSync(d, { withFileTypes: true });
+            for (const entry of entries) {
+                const fullPath = path.join(d, entry.name);
+                if (entry.isDirectory()) {
+                    walk(fullPath);
+                }
+                else if (entry.name.endsWith('.class')) {
+                    files.push(fullPath);
+                }
+            }
+        };
+        walk(dir);
+        return files;
+    }
+    /**
+     * Run a command and return result
+     */
+    runCommand(cmd, args) {
+        return new Promise((resolve) => {
+            const proc = (0, child_process_1.spawn)(cmd, args, {
+                shell: os.platform() === 'win32',
+                env: process.env
+            });
+            let stdout = '';
+            let stderr = '';
+            proc.stdout?.on('data', (data) => {
+                stdout += data.toString();
+            });
+            proc.stderr?.on('data', (data) => {
+                stderr += data.toString();
+            });
+            proc.on('close', (code) => {
+                resolve({
+                    success: code === 0,
+                    stdout,
+                    stderr
+                });
+            });
+            proc.on('error', (err) => {
+                resolve({
+                    success: false,
+                    stdout: '',
+                    stderr: err.message
+                });
+            });
+        });
+    }
+}
+exports.KotlinCompiler = KotlinCompiler;
+//# sourceMappingURL=kotlin-compiler.js.map

package/dist/build/kotlin-parser.d.ts

@@ -0,0 +1,91 @@
+export declare enum TokenType {
+    Identifier = 0,
+    StringLiteral = 1,
+    NumberLiteral = 2,
+    ParenOpen = 3,
+    ParenClose = 4,
+    BraceOpen = 5,
+    BraceClose = 6,
+    Equals = 7,
+    Comma = 8,
+    Dot = 9,
+    Colon = 10,
+    Keyword = 11,
+    Operator = 12,
+    EOF = 13
+}
+export interface Token {
+    type: TokenType;
+    value: string;
+    line: number;
+    column: number;
+}
+export declare class Tokenizer {
+    private content;
+    private position;
+    private line;
+    private column;
+    constructor(content: string);
+    tokenize(): Token[];
+    private advance;
+    private peek;
+    private createToken;
+    private skipLineComment;
+    private skipBlockComment;
+    private readIdentifier;
+    private readNumber;
+    private readString;
+}
+export declare class KotlinParser {
+    private tokens;
+    private position;
+    private library;
+    constructor(tokens: Token[], library?: Map<string, string>);
+    parse(): any;
+    private mapToDivKit;
+    private mapModifiersToPaddings;
+    private mapModifiersToSize;
+    private mapStyleToSize;
+    private parseBlockContent;
+    private parseStatement;
+    /**
+     * Consume parentheses content (after opening paren has been consumed)
+     */
+    private consumeParenthesesContent;
+    private parseFunctionCall;
+    private parseArguments;
+    private parseValue;
+    private parseValueOLD;
+    private consumeParentheses;
+    private continueParsingModifier;
+    /**
+     * Parse padding arguments: padding(16.dp) or padding(start = 16.dp, top = 8.dp, horizontal = 16.dp)
+     */
+    private parseModifierPaddingArgs;
+    private skipDeclaration;
+    /**
+     * Skip an assignment statement: identifier = expression
+     * Handles: showAddDialog = true, x = foo.bar(), etc.
+     */
+    private skipAssignment;
+    /**
+     * Consume an expression, handling nested parentheses, braces, and brackets.
+     * Stops at: comma, closing paren/brace (unmatched), keywords that start statements, or EOF.
+     */
+    private consumeExpression;
+    /**
+     * Skip lambda parameters at the start of a block: { padding -> ... } or { a, b -> ... }
+     * Returns true if parameters were skipped.
+     */
+    private skipLambdaParameters;
+    private match;
+    private check;
+    private advance;
+    private isAtEnd;
+    private peekCurrent;
+    private peek;
+    private previous;
+    private consume;
+    private consumeUntil;
+}
+//# sourceMappingURL=kotlin-parser.d.ts.map