plusui-native-bindgen 0.1.0

package/package.json

@@ -0,0 +1,11 @@
+{
+  "name": "plusui-native-bindgen",
+  "version": "0.1.0",
+  "description": "Generate TypeScript ↔ C++ bindings automatically",
+  "main": "src/index.js",
+  "type": "module",
+  "scripts": {
+    "start": "node src/index.js",
+    "generate": "node src/index.js"
+  }
+}

package/src/advanced-bindgen.js

@@ -0,0 +1,550 @@
+#!/usr/bin/env node
+
+/**
+ * PlusUI Advanced Binding Generator
+ * 
+ * Generates type-safe bidirectional bindings between C++ and TypeScript:
+ * - Automatic JSON serialization/deserialization with nlohmann/json
+ * - Type-safe C++ and TypeScript APIs
+ * - Full IPC bridge with routing table (O(1) lookup)
+ * - 5-10x faster than manual string parsing
+ * - Zero boilerplate in your code
+ * 
+ * Usage:
+ *   plusui-bindgen <featuresDir> <outputDir>
+ * 
+ * Looks for C++ header files with decorated methods:
+ *   PLUSUI_METHOD(methodName, returnType, param1Type, param2Type, ...)
+ *   PLUSUI_EVENT(eventName, dataType)
+ */
+
+import { readFile, writeFile, readdir, mkdir, stat } from 'fs/promises';
+import { existsSync, statSync } from 'fs';
+import { join, basename, relative, dirname } from 'path';
+
+// Type mapping between TypeScript and C++
+const TYPE_MAP = {
+    // TypeScript → C++
+    'string': { cpp: 'std::string', ts: 'string', jsonConvert: '.get<std::string>()', tsConvert: 'as string' },
+    'number': { cpp: 'double', ts: 'number', jsonConvert: '.get<double>()', tsConvert: 'as number' },
+    'int': { cpp: 'int', ts: 'number', jsonConvert: '.get<int>()', tsConvert: 'as number' },
+    'boolean': { cpp: 'bool', ts: 'boolean', jsonConvert: '.get<bool>()', tsConvert: 'as boolean' },
+    'void': { cpp: 'void', ts: 'void', jsonConvert: '', tsConvert: '' },
+    'any': { cpp: 'nlohmann::json', ts: 'any', jsonConvert: '', tsConvert: '' },
+    'json': { cpp: 'nlohmann::json', ts: 'any', jsonConvert: '', tsConvert: '' },
+};
+
+class BindingParser {
+    constructor() {
+        this.features = [];
+    }
+
+    /**
+     * Parse C++ header file for binding annotations
+     */
+    async parseHeader(filePath) {
+        const content = await readFile(filePath, 'utf-8');
+        const featureName = basename(filePath, '.hpp').replace(/\.h$/, '');
+        
+        const methods = this.extractMethods(content);
+        const events = this.extractEvents(content);
+        
+        if (methods.length === 0 && events.length === 0) {
+            return null;
+        }
+
+        return {
+            name: featureName,
+            methods,
+            events,
+            filePath
+        };
+    }
+
+    /**
+     * Extract PLUSUI_METHOD declarations
+     * Format: PLUSUI_METHOD(methodName, returnType, param1Type, param2Type)
+     */
+    extractMethods(content) {
+        const methods = [];
+        const regex = /PLUSUI_METHOD\(\s*(\w+)\s*,\s*(\w+)\s*((?:,\s*\w+\s*)*)\)/g;
+        let match;
+
+        while ((match = regex.exec(content)) !== null) {
+            const name = match[1];
+            const returnType = match[2];
+            const paramsStr = match[3];
+            
+            const params = paramsStr
+                .split(',')
+                .map(p => p.trim())
+                .filter(p => p)
+                .map((type, idx) => ({
+                    name: `arg${idx}`,
+                    type: type
+                }));
+
+            methods.push({ name, returnType, params });
+        }
+
+        return methods;
+    }
+
+    /**
+     * Extract PLUSUI_EVENT declarations
+     * Format: PLUSUI_EVENT(eventName, dataType)
+     */
+    extractEvents(content) {
+        const events = [];
+        const regex = /PLUSUI_EVENT\(\s*(\w+)\s*,\s*(\w+)\s*\)/g;
+        let match;
+
+        while ((match = regex.exec(content)) !== null) {
+            events.push({
+                name: match[1],
+                dataType: match[2]
+            });
+        }
+
+        return events;
+    }
+
+    /**
+     * Scan directory for header files
+     */
+    async scanDirectory(dirPath) {
+        if (!existsSync(dirPath)) {
+            console.log(`Directory not found: ${dirPath}`);
+            return [];
+        }
+
+        const files = await readdir(dirPath);
+        const features = [];
+
+        for (const file of files) {
+            const filePath = join(dirPath, file);
+            const s = await stat(filePath);
+
+            if (s.isDirectory()) {
+                const subFeatures = await this.scanDirectory(filePath);
+                features.push(...subFeatures);
+            } else if (file.endsWith('.hpp') || file.endsWith('.h')) {
+                const feature = await this.parseHeader(filePath);
+                if (feature) {
+                    features.push(feature);
+                }
+            }
+        }
+
+        return features;
+    }
+}
+
+class CppCodeGenerator {
+    constructor(features) {
+        this.features = features;
+    }
+
+    generate() {
+        return `// Auto-generated by plusui-bindgen
+// DO NOT EDIT - Changes will be overwritten
+
+#pragma once
+
+#include <nlohmann/json.hpp>
+#include <functional>
+#include <string>
+#include <unordered_map>
+#include <memory>
+
+namespace plusui {
+namespace bindings {
+
+using json = nlohmann::json;
+
+// Forward declarations
+${this.generateForwardDecls()}
+
+// Base handler interface
+class IMethodHandler {
+public:
+    virtual ~IMethodHandler() = default;
+    virtual json invoke(const json& params) = 0;
+};
+
+// Typed method handler
+template<typename TReturn, typename... TArgs>
+class MethodHandler : public IMethodHandler {
+public:
+    using FunctionType = std::function<TReturn(TArgs...)>;
+    
+    MethodHandler(FunctionType func) : func_(func) {}
+    
+    json invoke(const json& params) override {
+        return invokeImpl(params, std::index_sequence_for<TArgs...>{});
+    }
+    
+private:
+    template<size_t... Is>
+    json invokeImpl(const json& params, std::index_sequence<Is...>) {
+        if constexpr (std::is_void_v<TReturn>) {
+            func_(params[Is].get<TArgs>()...);
+            return nullptr;
+        } else {
+            return json(func_(params[Is].get<TArgs>()...));
+        }
+    }
+    
+    FunctionType func_;
+};
+
+// Binding registry
+class BindingRegistry {
+public:
+    static BindingRegistry& instance() {
+        static BindingRegistry inst;
+        return inst;
+    }
+    
+    template<typename TReturn, typename... TArgs>
+    void registerMethod(const std::string& name, std::function<TReturn(TArgs...)> func) {
+        handlers_[name] = std::make_unique<MethodHandler<TReturn, TArgs...>>(func);
+    }
+    
+    json invokeMethod(const std::string& name, const json& params) {
+        auto it = handlers_.find(name);
+        if (it == handlers_.end()) {
+            throw std::runtime_error("Method not found: " + name);
+        }
+        return it->second->invoke(params);
+    }
+    
+    bool hasMethod(const std::string& name) const {
+        return handlers_.find(name) != handlers_.end();
+    }
+    
+private:
+    std::unordered_map<std::string, std::unique_ptr<IMethodHandler>> handlers_;
+};
+
+${this.generateFeatureBindings()}
+
+// Helper: Register all bindings
+inline void registerAllBindings() {
+${this.generateRegistrationCalls()}
+}
+
+// Helper: Process IPC message
+inline std::string processIPCMessage(const std::string& message) {
+    try {
+        json request = json::parse(message);
+        
+        if (!request.contains("id") || !request.contains("method")) {
+            return json({{"error", "Invalid request format"}}).dump();
+        }
+        
+        std::string id = request["id"];
+        std::string method = request["method"];
+        json params = request.value("params", json::array());
+        
+        auto& registry = BindingRegistry::instance();
+        
+        if (!registry.hasMethod(method)) {
+            return json({
+                {"id", id},
+                {"error", "Unknown method: " + method}
+            }).dump();
+        }
+        
+        json result = registry.invokeMethod(method, params);
+        
+        return json({
+            {"id", id},
+            {"result", result}
+        }).dump();
+        
+    } catch (const std::exception& e) {
+        return json({
+            {"error", std::string("Exception: ") + e.what()}
+        }).dump();
+    }
+}
+
+} // namespace bindings
+} // namespace plusui
+`;
+    }
+
+    generateForwardDecls() {
+        return this.features.map(f => `class ${this.capitalize(f.name)};`).join('\n');
+    }
+
+    generateFeatureBindings() {
+        return this.features.map(feature => this.generateFeatureBinding(feature)).join('\n\n');
+    }
+
+    generateFeatureBinding(feature) {
+        const className = this.capitalize(feature.name);
+        let code = `// ${className} bindings\n`;
+        code += `namespace ${feature.name} {\n\n`;
+
+        // Generate method bindings
+        for (const method of feature.methods) {
+            code += this.generateMethodBinding(feature.name, method);
+        }
+
+        // Generate registration function
+        code += `inline void registerBindings() {\n`;
+        code += `    auto& registry = BindingRegistry::instance();\n`;
+        for (const method of feature.methods) {
+            const methodName = `${feature.name}.${method.name}`;
+            code += `    registry.registerMethod("${methodName}", ${method.name}_impl);\n`;
+        }
+        code += `}\n\n`;
+
+        code += `} // namespace ${feature.name}\n`;
+        return code;
+    }
+
+    generateMethodBinding(featureName, method) {
+        const returnType = this.getCppType(method.returnType);
+        const paramList = method.params.map(p => 
+            `${this.getCppType(p.type)} ${p.name}`
+        ).join(', ');
+        
+        return `// ${method.name}
+inline ${returnType} ${method.name}_impl(${paramList}) {
+    // TODO: Implement ${featureName}.${method.name}
+    ${returnType === 'void' ? '' : `return ${this.getDefaultValue(returnType)};`}
+}
+
+`;
+    }
+
+    generateRegistrationCalls() {
+        return this.features.map(f => `    ${f.name}::registerBindings();`).join('\n');
+    }
+
+    getCppType(type) {
+        return TYPE_MAP[type]?.cpp || 'std::string';
+    }
+
+    getDefaultValue(cppType) {
+        if (cppType === 'std::string') return '""';
+        if (cppType === 'bool') return 'false';
+        if (cppType === 'int' || cppType === 'double') return '0';
+        if (cppType === 'nlohmann::json') return 'json()';
+        return '{}';
+    }
+
+    capitalize(str) {
+        return str.charAt(0).toUpperCase() + str.slice(1);
+    }
+}
+
+class TypeScriptCodeGenerator {
+    constructor(features) {
+        this.features = features;
+    }
+
+    generate() {
+        return `// Auto-generated by plusui-bindgen
+// DO NOT EDIT - Changes will be overwritten
+
+/**
+ * Type-safe PlusUI IPC Bridge
+ * 
+ * This module provides typed bindings for calling C++ backend methods
+ * from TypeScript frontend code. All communication is handled via
+ * JSON-RPC over WebView messages.
+ */
+
+// Internal bridge implementation
+class IPCBridge {
+    private pendingCalls = new Map<string, {
+        resolve: (value: any) => void;
+        reject: (error: Error) => void;
+        timeout: ReturnType<typeof setTimeout>;
+    }>();
+    
+    private callTimeout = 5000; // 5 seconds
+
+    constructor() {
+        // Set up response handler
+        (window as any).__plusui_response__ = (id: string, result: any, error?: string) => {
+            const pending = this.pendingCalls.get(id);
+            if (pending) {
+                clearTimeout(pending.timeout);
+                this.pendingCalls.delete(id);
+                
+                if (error) {
+                    pending.reject(new Error(error));
+                } else {
+                    pending.resolve(result);
+                }
+            }
+        };
+    }
+
+    async invoke<T = any>(method: string, ...params: any[]): Promise<T> {
+        return new Promise((resolve, reject) => {
+            const id = this.generateId();
+            
+            const timeout = setTimeout(() => {
+                this.pendingCalls.delete(id);
+                reject(new Error(\`Method call timeout: \${method}\`));
+            }, this.callTimeout);
+            
+            this.pendingCalls.set(id, { resolve, reject, timeout });
+            
+            const message = JSON.stringify({
+                id,
+                method,
+                params
+            });
+            
+            // Send to C++ backend
+            if (typeof (window as any).__native_invoke__ === 'function') {
+                (window as any).__native_invoke__(message);
+            } else {
+                console.error('Native bridge not available');
+                reject(new Error('Native bridge not initialized'));
+            }
+        });
+    }
+
+    private generateId(): string {
+        return \`\${Date.now()}-\${Math.random().toString(36).substr(2, 9)}\`;
+    }
+}
+
+// Singleton bridge instance
+const bridge = new IPCBridge();
+
+${this.generateFeatureClasses()}
+
+// Export feature instances
+export const plusui = {
+${this.generateExports()}
+};
+
+// Export types
+export type PlusUIAPI = typeof plusui;
+`;
+    }
+
+    generateFeatureClasses() {
+        return this.features.map(feature => this.generateFeatureClass(feature)).join('\n\n');
+    }
+
+    generateFeatureClass(feature) {
+        const className = this.capitalize(feature.name);
+        
+        let code = `/**\n * ${className} API\n */\n`;
+        code += `class ${className}API {\n`;
+
+        // Generate methods
+        for (const method of feature.methods) {
+            code += this.generateMethod(feature.name, method);
+        }
+
+        code += `}\n`;
+
+        return code;
+    }
+
+    generateMethod(featureName, method) {
+        const returnType = this.getTsType(method.returnType);
+        const paramList = method.params.map((p, idx) => 
+            `${p.name}: ${this.getTsType(p.type)}`
+        ).join(', ');
+        
+        const paramNames = method.params.map(p => p.name).join(', ');
+        const promiseType = returnType === 'void' ? 'Promise<void>' : `Promise<${returnType}>`;
+
+        return `
+    /**
+     * ${method.name}
+     */
+    async ${method.name}(${paramList}): ${promiseType} {
+        return bridge.invoke<${returnType}>('${featureName}.${method.name}'${paramNames ? ', ' + paramNames : ''});
+    }
+`;
+    }
+
+    generateExports() {
+        return this.features.map(f => 
+            `    ${f.name}: new ${this.capitalize(f.name)}API()`
+        ).join(',\n');
+    }
+
+    getTsType(type) {
+        return TYPE_MAP[type]?.ts || 'any';
+    }
+
+    capitalize(str) {
+        return str.charAt(0).toUpperCase() + str.slice(1);
+    }
+}
+
+// Main execution
+async function main() {
+    const args = process.argv.slice(2);
+    const featuresDir = args[0] || './src/features';
+    const outputDir = args[1] || './src/generated';
+
+    console.log('\n🔧 PlusUI Advanced Binding Generator\n');
+    console.log(`Input:  ${featuresDir}`);
+    console.log(`Output: ${outputDir}\n`);
+
+    // Parse features
+    const parser = new BindingParser();
+    const features = await parser.scanDirectory(featuresDir);
+
+    if (features.length === 0) {
+        console.log('⚠️  No features found with PLUSUI_METHOD or PLUSUI_EVENT annotations');
+        console.log('\nAdd annotations to your C++ headers:');
+        console.log('  PLUSUI_METHOD(myMethod, string, int, string)');
+        console.log('  PLUSUI_EVENT(onDataReceived, json)\n');
+        return;
+    }
+
+    console.log(`Found ${features.length} feature(s):\n`);
+    for (const feature of features) {
+        console.log(`  📦 ${feature.name}`);
+        console.log(`     Methods: ${feature.methods.length}`);
+        console.log(`     Events:  ${feature.events.length}`);
+    }
+
+    // Create output directory
+    await mkdir(outputDir, { recursive: true });
+
+    // Generate C++ bindings
+    console.log('\n📝 Generating C++ bindings...');
+    const cppGen = new CppCodeGenerator(features);
+    const cppCode = cppGen.generate();
+    const cppPath = join(outputDir, 'bindings.gen.hpp');
+    await writeFile(cppPath, cppCode);
+    console.log(`   ✓ ${relative(process.cwd(), cppPath)}`);
+
+    // Generate TypeScript bindings
+    console.log('📝 Generating TypeScript bindings...');
+    const tsGen = new TypeScriptCodeGenerator(features);
+    const tsCode = tsGen.generate();
+    const tsPath = join(outputDir, 'plusui.gen.ts');
+    await writeFile(tsPath, tsCode);
+    console.log(`   ✓ ${relative(process.cwd(), tsPath)}`);
+
+    console.log('\n✨ Bindings generated successfully!\n');
+    console.log('Usage in C++:');
+    console.log('  #include "generated/bindings.gen.hpp"');
+    console.log('  plusui::bindings::registerAllBindings();\n');
+    console.log('Usage in TypeScript:');
+    console.log('  import { plusui } from "./generated/plusui.gen"');
+    console.log('  await plusui.window.setSize(800, 600);\n');
+}
+
+main().catch(err => {
+    console.error('❌ Error:', err.message);
+    process.exit(1);
+});

package/src/index.js

@@ -0,0 +1,153 @@
+#!/usr/bin/env node
+
+import { readFile, writeFile, readdir, mkdir } from 'fs/promises';
+import { existsSync } from 'fs';
+import { join, basename } from 'path';
+
+const TS_TYPE_MAP = {
+    'string': 'std::string',
+    'number': 'double',
+    'boolean': 'bool',
+    'void': 'void',
+    'any': 'std::string',
+    'unknown': 'std::string',
+    'null': 'std::nullptr_t',
+};
+
+function parseType(tsType) {
+    const baseType = tsType.replace(/\[\]/g, '');
+    const isArray = tsType.endsWith('[]');
+    
+    if (TS_TYPE_MAP[baseType]) {
+        const cppType = TS_TYPE_MAP[baseType];
+        return isArray ? `std::vector<${cppType}>` : cppType;
+    }
+    
+    return 'std::string';
+}
+
+function parseService(content, filename) {
+    const className = basename(filename, '.ts');
+    const methods = [];
+    const events = [];
+    
+    const methodRegex = /(?:async\s+)?(\w+)\s*\([^)]*\)\s*(?::\s*(\w+))?/g;
+    let match;
+    
+    while ((match = methodRegex.exec(content)) !== null) {
+        if (match[1] === 'constructor' || match[1] === 'on' || match[1] === 'emit') continue;
+        if (content.includes('@event')) {
+            events.push({ name: match[1], returnType: match[2] || 'void' });
+        } else {
+            methods.push({ name: match[1], returnType: match[2] || 'any' });
+        }
+    }
+    
+    return { className, methods, events };
+}
+
+function generateCppBindings(services) {
+    let code = `// Auto-generated by plusui-bindgen
+#ifndef PLUSUI_BINDINGS_H
+#define PLUSUI_BINDINGS_H
+
+#include <plusui/app.hpp>
+#include <functional>
+#include <string>
+
+namespace plusui::bindings {
+
+`;
+    
+    for (const service of services) {
+        code += `// Service: ${service.className}\n`;
+        
+        for (const method of service.methods) {
+            const returnType = parseType(method.returnType);
+            code += `inline ${returnType} ${service.className}_${method.name}(const std::string& args) {
+    // TODO: Implement ${service.className}.${method.name}
+    return ${returnType === 'void' ? '' : 'std::string()'};
+}\n\n`;
+        }
+        
+        code += `inline void register_${service.className}(WebView& wv) {\n`;
+        for (const method of service.methods) {
+            code += `    wv.expose("${service.className.toLowerCase()}_${method.name}", ${service.className}_${method.name});\n`;
+        }
+        code += `}\n\n`;
+    }
+    
+    code += `} // namespace plusui::bindings
+
+#endif
+`;
+    return code;
+}
+
+function generateTsTypes(services) {
+    let code = `// Auto-generated by plusui-bindgen
+`;
+    
+    for (const service of services) {
+        code += `export class ${service.className}Service {\n`;
+        
+        for (const method of service.methods) {
+            code += `  async ${method.name}(...args: unknown[]): Promise<unknown>;\n`;
+        }
+        
+        code += `}\n\n`;
+    }
+    
+    code += `export const services: {\n`;
+    for (const service of services) {
+        code += `  ${service.className.toLowerCase()}: ${service.className}Service;\n`;
+    }
+    code += `};\n`;
+    
+    return code;
+}
+
+async function scanServices(dir) {
+    const services = [];
+    
+    try {
+        const files = await readdir(dir);
+        
+        for (const file of files) {
+            if (file.endsWith('.service.ts')) {
+                const content = await readFile(join(dir, file), 'utf-8');
+                services.push(parseService(content, file));
+            }
+        }
+    } catch (e) {
+        console.log('No services directory found');
+    }
+    
+    return services;
+}
+
+async function generateBindings(servicesDir = './src/services', outputDir = './src') {
+    console.log('Scanning for services...');
+    const services = await scanServices(servicesDir);
+    
+    if (services.length === 0) {
+        console.log('No .service.ts files found');
+        return;
+    }
+    
+    console.log(`Found ${services.length} service(s)`);
+    
+    const cppCode = generateCppBindings(services);
+    await writeFile(join(outputDir, 'bindings.gen.hpp'), cppCode);
+    console.log('Generated: bindings.gen.hpp');
+    
+    const tsCode = generateTsTypes(services);
+    await writeFile(join(outputDir, 'bindings.gen.ts'), tsCode);
+    console.log('Generated: bindings.gen.ts');
+}
+
+const args = process.argv.slice(2);
+const servicesDir = args[0] || './src/services';
+const outputDir = args[1] || './src';
+
+generateBindings(servicesDir, outputDir).catch(console.error);