@jetstart/core 1.7.0 → 2.0.0

package/dist/build/override-generator.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Override Generator
+ * Generates $override classes that implement IncrementalChange interface.
+ * These classes contain the new method implementations and route calls via access$dispatch.
+ */
+export interface OverrideGeneratorResult {
+    success: boolean;
+    overrideClassFiles: string[];
+    errors: string[];
+}
+export declare class OverrideGenerator {
+    private static readonly TAG;
+    /**
+     * Generate $override classes for all compiled class files.
+     * The override classes implement IncrementalChange and contain the new method implementations.
+     *
+     * Strategy: Instead of complex bytecode manipulation, we generate Kotlin source code
+     * for the $Override classes and compile them. This is simpler and more maintainable.
+     */
+    generateOverrides(classFiles: string[], sourceFile: string, outputDir: string): Promise<OverrideGeneratorResult>;
+    /**
+     * Parse Kotlin source file to extract class and method information
+     */
+    private parseKotlinSource;
+    /**
+     * Parse methods from a class body
+     */
+    private parseMethodsFromClassBody;
+    /**
+     * Parse top-level functions (not inside a class)
+     */
+    private parseTopLevelFunctions;
+    /**
+     * Parse parameter string into typed parameters
+     */
+    private parseParameters;
+    /**
+     * Parse a single parameter definition
+     */
+    private parseParameter;
+    /**
+     * Generate a method signature string for dispatch routing
+     */
+    private generateMethodSignature;
+    /**
+     * Convert Kotlin type to JVM descriptor-style string
+     */
+    private typeToDescriptor;
+    /**
+     * Generate Kotlin source code for the $override class
+     */
+    private generateOverrideSource;
+}
+//# sourceMappingURL=override-generator.d.ts.map

package/dist/build/override-generator.js

@@ -0,0 +1,430 @@
+"use strict";
+/**
+ * Override Generator
+ * Generates $override classes that implement IncrementalChange interface.
+ * These classes contain the new method implementations and route calls via access$dispatch.
+ */
+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.OverrideGenerator = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const logger_1 = require("../utils/logger");
+class OverrideGenerator {
+    static TAG = 'OverrideGenerator';
+    /**
+     * Generate $override classes for all compiled class files.
+     * The override classes implement IncrementalChange and contain the new method implementations.
+     *
+     * Strategy: Instead of complex bytecode manipulation, we generate Kotlin source code
+     * for the $Override classes and compile them. This is simpler and more maintainable.
+     */
+    async generateOverrides(classFiles, sourceFile, outputDir) {
+        const overrideClassFiles = [];
+        const errors = [];
+        try {
+            // Read the original Kotlin source to understand method signatures
+            const sourceContent = fs.readFileSync(sourceFile, 'utf-8');
+            // Parse class and method information from source
+            const classInfo = this.parseKotlinSource(sourceContent, sourceFile);
+            if (classInfo.length === 0) {
+                // No classes found - this is normal for files with only @Composable functions
+                // Return success with 0 overrides and let the fallback handle it
+                (0, logger_1.log)(`ℹ️ No classes found in ${sourceFile} - using direct class hot reload`);
+                return { success: true, overrideClassFiles: [], errors: [] };
+            }
+            // Generate override class source for each class
+            for (const info of classInfo) {
+                const overrideSource = this.generateOverrideSource(info);
+                const overrideSourcePath = path.join(outputDir, `${info.className}\$override.kt`);
+                fs.writeFileSync(overrideSourcePath, overrideSource);
+                (0, logger_1.log)(`Generated override source: ${info.className}$override.kt`);
+                // Track the generated source file
+                overrideClassFiles.push(overrideSourcePath);
+            }
+            return {
+                success: true,
+                overrideClassFiles,
+                errors: []
+            };
+        }
+        catch (e) {
+            const errorMsg = e instanceof Error ? e.message : String(e);
+            errors.push(errorMsg);
+            return { success: false, overrideClassFiles: [], errors };
+        }
+    }
+    /**
+     * Parse Kotlin source file to extract class and method information
+     */
+    parseKotlinSource(source, filePath) {
+        const classes = [];
+        // Extract package name
+        const packageMatch = source.match(/^package\s+([\w.]+)/m);
+        const packageName = packageMatch ? packageMatch[1] : '';
+        // Simple regex-based parsing for class definitions
+        // This handles basic cases - complex nested classes may need more sophisticated parsing
+        const classRegex = /(?:class|object)\s+(\w+)(?:\s*:\s*[\w\s,<>]+)?\s*\{/g;
+        let classMatch;
+        while ((classMatch = classRegex.exec(source)) !== null) {
+            const className = classMatch[1];
+            const classStartIndex = classMatch.index;
+            // Find matching closing brace
+            let braceCount = 0;
+            let classEndIndex = classStartIndex;
+            let inString = false;
+            let stringChar = '';
+            for (let i = classStartIndex; i < source.length; i++) {
+                const char = source[i];
+                const prevChar = i > 0 ? source[i - 1] : '';
+                // Handle string literals
+                if ((char === '"' || char === '\'') && prevChar !== '\\') {
+                    if (!inString) {
+                        inString = true;
+                        stringChar = char;
+                    }
+                    else if (char === stringChar) {
+                        inString = false;
+                    }
+                }
+                if (!inString) {
+                    if (char === '{')
+                        braceCount++;
+                    if (char === '}') {
+                        braceCount--;
+                        if (braceCount === 0) {
+                            classEndIndex = i;
+                            break;
+                        }
+                    }
+                }
+            }
+            const classBody = source.substring(classStartIndex, classEndIndex + 1);
+            const methods = this.parseMethodsFromClassBody(classBody, className);
+            classes.push({
+                packageName,
+                className,
+                fullClassName: packageName ? `${packageName}.${className}` : className,
+                methods
+            });
+        }
+        // Also handle top-level functions (they go in FileNameKt class)
+        const topLevelMethods = this.parseTopLevelFunctions(source, filePath);
+        if (topLevelMethods.length > 0) {
+            const fileName = path.basename(filePath, '.kt');
+            const ktClassName = fileName.charAt(0).toUpperCase() + fileName.slice(1) + 'Kt';
+            classes.push({
+                packageName,
+                className: ktClassName,
+                fullClassName: packageName ? `${packageName}.${ktClassName}` : ktClassName,
+                methods: topLevelMethods
+            });
+        }
+        return classes;
+    }
+    /**
+     * Parse methods from a class body
+     */
+    parseMethodsFromClassBody(classBody, className) {
+        const methods = [];
+        // Match function definitions
+        // This regex handles: fun name(params): ReturnType
+        const funRegex = /fun\s+(\w+)\s*\(([^)]*)\)(?:\s*:\s*([\w<>?,\s]+))?\s*[{=]/g;
+        let funMatch;
+        while ((funMatch = funRegex.exec(classBody)) !== null) {
+            const methodName = funMatch[1];
+            const paramsStr = funMatch[2];
+            const returnType = funMatch[3]?.trim() || 'Unit';
+            // Parse parameters
+            const params = this.parseParameters(paramsStr);
+            // Generate method signature for dispatch
+            const signature = this.generateMethodSignature(methodName, params, returnType);
+            methods.push({
+                name: methodName,
+                parameters: params,
+                returnType,
+                signature,
+                isStatic: false // Assume instance method, TODO: detect companion object
+            });
+        }
+        return methods;
+    }
+    /**
+     * Parse top-level functions (not inside a class)
+     */
+    parseTopLevelFunctions(source, filePath) {
+        const methods = [];
+        // Remove class bodies first to get only top-level content
+        let topLevelContent = source;
+        // Remove all class/object bodies
+        const classRegex = /(?:class|object)\s+\w+[^{]*\{/g;
+        let match;
+        const classPositions = [];
+        while ((match = classRegex.exec(source)) !== null) {
+            const startIndex = match.index;
+            let braceCount = 0;
+            let endIndex = startIndex;
+            let inString = false;
+            let stringChar = '';
+            for (let i = startIndex; i < source.length; i++) {
+                const char = source[i];
+                const prevChar = i > 0 ? source[i - 1] : '';
+                if ((char === '"' || char === '\'') && prevChar !== '\\') {
+                    if (!inString) {
+                        inString = true;
+                        stringChar = char;
+                    }
+                    else if (char === stringChar) {
+                        inString = false;
+                    }
+                }
+                if (!inString) {
+                    if (char === '{')
+                        braceCount++;
+                    if (char === '}') {
+                        braceCount--;
+                        if (braceCount === 0) {
+                            endIndex = i;
+                            break;
+                        }
+                    }
+                }
+            }
+            classPositions.push({ start: startIndex, end: endIndex + 1 });
+        }
+        // Sort and remove class bodies from end to start to maintain indices
+        classPositions.sort((a, b) => b.start - a.start);
+        for (const pos of classPositions) {
+            topLevelContent = topLevelContent.substring(0, pos.start) + topLevelContent.substring(pos.end);
+        }
+        // Now parse functions from top-level content
+        const funRegex = /fun\s+(\w+)\s*\(([^)]*)\)(?:\s*:\s*([\w<>?,\s]+))?\s*[{=]/g;
+        let funMatch;
+        while ((funMatch = funRegex.exec(topLevelContent)) !== null) {
+            const methodName = funMatch[1];
+            const paramsStr = funMatch[2];
+            const returnType = funMatch[3]?.trim() || 'Unit';
+            const params = this.parseParameters(paramsStr);
+            const signature = this.generateMethodSignature(methodName, params, returnType);
+            methods.push({
+                name: methodName,
+                parameters: params,
+                returnType,
+                signature,
+                isStatic: true // Top-level functions are static
+            });
+        }
+        return methods;
+    }
+    /**
+     * Parse parameter string into typed parameters
+     */
+    parseParameters(paramsStr) {
+        if (!paramsStr.trim())
+            return [];
+        const params = [];
+        // Split by comma, but respect generics
+        let depth = 0;
+        let current = '';
+        for (const char of paramsStr) {
+            if (char === '<' || char === '(')
+                depth++;
+            if (char === '>' || char === ')')
+                depth--;
+            if (char === ',' && depth === 0) {
+                if (current.trim()) {
+                    const param = this.parseParameter(current.trim());
+                    if (param)
+                        params.push(param);
+                }
+                current = '';
+            }
+            else {
+                current += char;
+            }
+        }
+        if (current.trim()) {
+            const param = this.parseParameter(current.trim());
+            if (param)
+                params.push(param);
+        }
+        return params;
+    }
+    /**
+     * Parse a single parameter definition
+     */
+    parseParameter(paramStr) {
+        // Handle "name: Type" or "name: Type = default"
+        const match = paramStr.match(/(\w+)\s*:\s*([\w<>?,.\s]+?)(?:\s*=.*)?$/);
+        if (!match)
+            return null;
+        return {
+            name: match[1],
+            type: match[2].trim()
+        };
+    }
+    /**
+     * Generate a method signature string for dispatch routing
+     */
+    generateMethodSignature(methodName, params, returnType) {
+        // Format: methodName.(paramTypes)returnType
+        // Using JVM-style descriptors
+        const paramDescriptors = params.map(p => this.typeToDescriptor(p.type)).join('');
+        const returnDescriptor = this.typeToDescriptor(returnType);
+        return `${methodName}.(${paramDescriptors})${returnDescriptor}`;
+    }
+    /**
+     * Convert Kotlin type to JVM descriptor-style string
+     */
+    typeToDescriptor(type) {
+        // Simplified mapping - expand as needed
+        const typeMap = {
+            'Unit': 'V',
+            'Int': 'I',
+            'Long': 'J',
+            'Float': 'F',
+            'Double': 'D',
+            'Boolean': 'Z',
+            'Byte': 'B',
+            'Char': 'C',
+            'Short': 'S',
+            'String': 'Ljava/lang/String;',
+            'Any': 'Ljava/lang/Object;',
+        };
+        // Handle nullable types
+        const nonNullType = type.replace('?', '');
+        if (typeMap[nonNullType]) {
+            return typeMap[nonNullType];
+        }
+        // Handle generic types like List<String>
+        const genericMatch = nonNullType.match(/^(\w+)<.*>$/);
+        if (genericMatch) {
+            return `L${genericMatch[1]};`;
+        }
+        // Default to object type
+        return `L${nonNullType.replace('.', '/')};`;
+    }
+    /**
+     * Generate Kotlin source code for the $override class
+     */
+    generateOverrideSource(classInfo) {
+        const { packageName, className, methods } = classInfo;
+        const lines = [];
+        // Package declaration
+        if (packageName) {
+            lines.push(`package ${packageName}`);
+            lines.push('');
+        }
+        // Import IncrementalChange
+        lines.push('import com.jetstart.hotreload.IncrementalChange');
+        lines.push('');
+        // Generate override class
+        lines.push(`/**`);
+        lines.push(` * Generated override class for ${className}`);
+        lines.push(` * Implements IncrementalChange to provide hot-reloaded method implementations`);
+        lines.push(` * `);
+        lines.push(` * Pattern: args[0] is 'this' for instance methods, method parameters follow`);
+        lines.push(` */`);
+        lines.push(`class ${className}\$override : IncrementalChange {`);
+        lines.push('');
+        // Generate access$dispatch method
+        lines.push('    override fun access\$dispatch(methodSignature: String, vararg args: Any?): Any? {');
+        lines.push('        return when (methodSignature) {');
+        for (const method of methods) {
+            const { name, parameters, returnType, signature, isStatic } = method;
+            // Generate case for this method
+            lines.push(`            "${signature}" -> {`);
+            // For instance methods, cast args[0] to the instance type
+            if (!isStatic) {
+                lines.push(`                val instance = args[0] as ${className}`);
+            }
+            // Cast arguments and call the method
+            if (parameters.length === 0) {
+                if (returnType === 'Unit') {
+                    if (isStatic) {
+                        lines.push(`                ${className}.${name}()`);
+                    }
+                    else {
+                        lines.push(`                instance.${name}()`);
+                    }
+                    lines.push('                null');
+                }
+                else {
+                    if (isStatic) {
+                        lines.push(`                ${className}.${name}()`);
+                    }
+                    else {
+                        lines.push(`                instance.${name}()`);
+                    }
+                }
+            }
+            else {
+                // Build argument list with casts
+                const argCasts = parameters.map((p, i) => {
+                    // For instance methods: args[0] is 'this', method params start at args[1]
+                    // For static methods: method params start at args[0]
+                    const argIndex = isStatic ? i : i + 1;
+                    return `args[${argIndex}] as ${p.type}`;
+                });
+                if (returnType === 'Unit') {
+                    if (isStatic) {
+                        lines.push(`                ${className}.${name}(${argCasts.join(', ')})`);
+                    }
+                    else {
+                        lines.push(`                instance.${name}(${argCasts.join(', ')})`);
+                    }
+                    lines.push('                null');
+                }
+                else {
+                    if (isStatic) {
+                        lines.push(`                ${className}.${name}(${argCasts.join(', ')})`);
+                    }
+                    else {
+                        lines.push(`                instance.${name}(${argCasts.join(', ')})`);
+                    }
+                }
+            }
+            lines.push('            }');
+        }
+        // Default case
+        lines.push('            else -> throw IllegalArgumentException("Unknown method: $methodSignature")');
+        lines.push('        }');
+        lines.push('    }');
+        lines.push('}');
+        return lines.join('\n');
+    }
+}
+exports.OverrideGenerator = OverrideGenerator;
+//# sourceMappingURL=override-generator.js.map

package/dist/server/index.d.ts

@@ -9,6 +9,10 @@ export interface ServerConfig {
     wsPort?: number;
     host?: string;
     displayHost?: string;
+    /** Override the URL injected into BuildConfig for emulator builds. Emulators reach the host at 10.0.2.2, not the local network IP. */
+    emulatorHost?: string;
+    /** Enable web emulator support (initializes kotlinc-js compiler). */
+    webEnabled?: boolean;
     projectPath?: string;
     projectName?: string;
 }
@@ -20,9 +24,15 @@ export declare class JetStartServer extends EventEmitter {
     private config;
     private sessionManager;
     private buildService;
+    private hotReloadService;
+    private jsCompiler;
     private currentSession;
     private buildMutex;
     private latestApkPath;
+    private useTrueHotReload;
+    private adbHelper;
+    private autoInstall;
+    private isFileChangeBuild;
     constructor(config?: ServerConfig);
     start(): Promise<ServerSession>;
     stop(): Promise<void>;
@@ -30,8 +40,13 @@ export declare class JetStartServer extends EventEmitter {
     private setupBuildListeners;
     private handleRebuild;
     /**
-     * Handle UI file updates using DSL hot reload (FAST)
+     * Handle UI file updates - uses TRUE hot reload (DEX-based) when available
      */
+    /**
+     * Compile a .kt file to a browser ES module and broadcast to web clients.
+     * Physical devices use DEX (already sent above). This targets browsers only.
+     */
+    private sendJsPreview;
     private handleUIUpdate;
 }
 //# sourceMappingURL=index.d.ts.map