plusui-native-builder 0.1.0

package/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "plusui-native-builder",
+  "version": "0.1.0",
+  "description": "Multi-platform build tool for PlusUI projeplusui",
+  "main": "src/index.js",
+  "type": "module",
+  "bin": {
+    "plusui-builder": "./src/index.js"
+  },
+  "scripts": {
+    "start": "node src/index.js",
+    "build": "node src/index.js",
+    "build:win32": "node src/index.js win32",
+    "build:all": "node src/index.js all"
+  },
+  "keywords": ["plusui", "build", "multiplatform", "android", "ios", "windows", "macos", "linux"],
+  "license": "MIT",
+  "dependencies": {
+    "plusui-native-bindgen": "*"
+  }
+}

package/src/index.js

@@ -0,0 +1,230 @@
+#!/usr/bin/env node
+
+import { execSync, spawn } from 'child_process';
+import { existsSync, mkdirSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+const COLORS = {
+    reset: '\x1b[0m',
+    bright: '\x1b[1m',
+    green: '\x1b[32m',
+    blue: '\x1b[34m',
+    yellow: '\x1b[33m',
+    red: '\x1b[31m',
+};
+
+function log(msg, color = 'reset') {
+    console.log(`${COLORS[color]}${msg}${COLORS.reset}`);
+}
+
+function error(msg) {
+    console.error(`${COLORS.red}Error: ${msg}${COLORS.reset}`);
+    process.exit(1);
+}
+
+const USAGE = `
+PlusUI Builder - Multi-platform build tool
+
+Usage:
+  plusui-builder                    Build for current platform
+  plusui-builder <platform>         Build for specific platform
+  plusui-builder all                Build for all platforms
+  plusui-builder generate           Generate bindings only
+
+Platforms:
+  win32        - Windows (x64)
+  macos        - macOS (x64, arm64)
+  linux        - Linux (x64)
+  android      - Android (arm64-v8a, armeabi-v7a, x86, x86_64)
+  ios          - iOS (simulator, device)
+
+Options:
+  -h, --help     Show this help
+  -v, --version  Show version
+`;
+
+const PLATFORMS = {
+    win32: { name: 'Windows', ext: '.exe', arch: ['x64'] },
+    macos: { name: 'macOS', ext: '', arch: ['x64', 'arm64'] },
+    linux: { name: 'Linux', ext: '', arch: ['x64'] },
+    android: { name: 'Android', ext: '.so', arch: ['arm64-v8a', 'armeabi-v7a', 'x86', 'x86_64'] },
+    ios: { name: 'iOS', ext: '.app', arch: ['simulator', 'device'] },
+};
+
+function runCommand(cmd, options = {}) {
+    const { cwd = process.cwd(), env = process.env, fatal = true } = options;
+    try {
+        execSync(cmd, { cwd, env, stdio: 'inherit' });
+        return true;
+    } catch (e) {
+        if (fatal) error(`Command failed: ${cmd}`);
+        return false;
+    }
+}
+
+function generateBindings() {
+    log('Generating bindings...', 'blue');
+    let bindgenPath = join(__dirname, '..', '..', 'plusui-bindgen', 'src', 'index.js');
+    if (!existsSync(bindgenPath)) {
+        // Try installed location (node_modules/@plusui-native/bindgen)
+        bindgenPath = join(__dirname, '..', '..', '@plusui-native', 'bindgen', 'src', 'index.js');
+    }
+    
+    if (!existsSync(bindgenPath)) {
+        error('plusui-bindgen not found. Please ensure @plusui-native/bindgen is installed.');
+    }
+    
+    runCommand(`node ${bindgenPath} ./src/services ./src`);
+    log('Bindings generated ✓', 'green');
+}
+
+function getCMakePlatformArgs(platform) {
+    const args = [];
+    
+    switch (platform) {
+        case 'win32':
+            break;
+        case 'macos':
+            args.push('-G', 'Xcode');
+            break;
+        case 'linux':
+            args.push('-G', 'Ninja');
+            break;
+        case 'android':
+            const sdkRoot = process.env.ANDROID_SDK_ROOT || process.env.ANDROID_HOME;
+            if (!sdkRoot) {
+                error('ANDROID_SDK_ROOT or ANDROID_HOME not set');
+            }
+            args.push('-G', 'Ninja');
+            args.push('-DCMAKE_TOOLCHAIN_FILE=' + join(sdkRoot, 'build-tools', 'cmake', 'android.toolchain.cmake'));
+            args.push('-DANDROID_NATIVE_API_LEVEL=24');
+            break;
+        case 'ios':
+            args.push('-G', 'Xcode');
+            args.push('-DCMAKE_SYSTEM_NAME=iOS');
+            break;
+    }
+    
+    return args;
+}
+
+function findCMakeLists() {
+    const root = process.cwd();
+    if (existsSync(join(root, 'CMakeLists.txt'))) {
+        return root;
+    }
+    const subdirs = ['.', 'src', 'app', 'core'];
+    for (const dir of subdirs) {
+        const path = join(root, dir, 'CMakeLists.txt');
+        if (existsSync(path)) {
+            return join(root, dir);
+        }
+    }
+    error('CMakeLists.txt not found. Run from a PlusUI project directory.');
+}
+
+function buildPlatform(platform, arch = null) {
+    const cfg = PLATFORMS[platform];
+    if (!cfg) {
+        error(`Unknown platform: ${platform}`);
+    }
+    
+    const sourceDir = findCMakeLists();
+    const archs = arch ? [arch] : cfg.arch;
+    
+    for (const targetArch of archs) {
+        log(`Building ${cfg.name} (${targetArch})...`, 'blue');
+        
+        const buildDir = join(sourceDir, 'build', platform, targetArch);
+        mkdirSync(buildDir, { recursive: true });
+        
+        const cmakeArgs = ['-S' + sourceDir, `-B${buildDir}`, '-DCMAKE_BUILD_TYPE=Release'];
+        cmakeArgs.push(...getCMakePlatformArgs(platform));
+        
+        if (platform === 'android') {
+            cmakeArgs.push(`-DANDROID_ABI=${targetArch}`);
+        }
+        
+        const cmakeCmd = 'cmake ' + cmakeArgs.join(' ');
+        runCommand(cmakeCmd);
+        runCommand(`cmake --build ${buildDir} --config Release`);
+        
+        log(`Built ${cfg.name} (${targetArch}) ✓`, 'green');
+    }
+}
+
+function buildCurrentPlatform() {
+    const platform = process.platform;
+    const platformMap = { 'win32': 'win32', 'darwin': 'macos', 'linux': 'linux' };
+    const targetPlatform = platformMap[platform];
+    
+    if (targetPlatform) {
+        buildPlatform(targetPlatform);
+    } else {
+        error(`Unsupported platform: ${platform}`);
+    }
+}
+
+function buildAll() {
+    generateBindings();
+    
+    for (const platform of Object.keys(PLATFORMS)) {
+        log(`\n=== Building for ${PLATFORMS[platform].name} ===`, 'yellow');
+        buildPlatform(platform);
+    }
+    
+    log('\n✓ All builds complete!', 'green');
+}
+
+function main() {
+    const args = process.argv.slice(2);
+    const cmd = args[0];
+    
+    switch (cmd) {
+        case 'generate':
+        case 'gen':
+            generateBindings();
+            break;
+        case 'all':
+            buildAll();
+            break;
+        case 'win32':
+        case 'windows':
+            generateBindings();
+            buildPlatform('win32');
+            break;
+        case 'macos':
+            generateBindings();
+            buildPlatform('macos');
+            break;
+        case 'linux':
+            generateBindings();
+            buildPlatform('linux');
+            break;
+        case 'android':
+            generateBindings();
+            buildPlatform('android');
+            break;
+        case 'ios':
+            generateBindings();
+            buildPlatform('ios');
+            break;
+        case '-h':
+        case '--help':
+            console.log(USAGE);
+            break;
+        case '-v':
+        case '--version':
+            console.log('plusui-builder v0.1.0');
+            break;
+        default:
+            generateBindings();
+            buildCurrentPlatform();
+    }
+}
+
+main();