cpp.js 1.0.0-beta.6 → 1.0.0

package/src/bin.js

@@ -1,12 +1,23 @@
 #!/usr/bin/env node
 
+import fs from 'node:fs';
+import { execFileSync } from 'node:child_process';
 import { Command, Option } from 'commander';
-import fs from 'fs';
-import glob from 'glob';
-import { createDir } from './utils/createTempDir.js';
-import getPathInfo from './utils/getPathInfo.js';
+import replace from 'replace';
 
-import CppjsCompiler from './index.js';
+import { state } from './index.js';
+import createBridgeFile from './actions/createInterface.js';
+import createLib from './actions/createLib.js';
+import buildWasm from './actions/buildWasm.js';
+import createXCFramework from './actions/createXCFramework.js';
+import runCppjsApp from './actions/run.js';
+import downloadAndExtractFile from './utils/downloadAndExtractFile.js';
+import writeJson from './utils/writeJson.js';
+import systemKeys from './utils/systemKeys.js';
+
+import { getDockerImage } from './utils/pullDockerImage.js';
+import { getContentHash } from './utils/hash.js';
+import findFiles from './utils/findFiles.js';
 
 const packageJSON = JSON.parse(fs.readFileSync(new URL('../package.json', import.meta.url)));
 
@@ -20,148 +31,296 @@ program
 
 const commandBuild = program.command('build')
     .description('compile the project that was set up using Cpp.js')
-    .addOption(new Option('-p, --platform <platform>', 'target platform').default('all').choices(['all', 'wasm', 'android', 'ios']));
+    .addOption(new Option('-p, --platform <platform>', 'target platform').default('All').choices(['All', 'WebAssembly', 'Android', 'iOS']));
 
-const commandRun = program.command('run')
-    .description('run docker application');
+const commandDocker = program.command('docker')
+    .description('manage docker');
+const commandRun = commandDocker.command('run').description('run docker application');
+commandDocker.command('create').description('create docker container');
+commandDocker.command('start').description('start docker container');
+commandDocker.command('stop').description('stop docker container');
+commandDocker.command('delete').description('delete docker container');
 
-const commandPostInstall = program.command('postinstall')
-    .description('prepare the required packages for Cpp.js after installation');
+const commandConfig = program.command('config')
+    .description('manage the Cpp.js configuration files');
+commandConfig.command('get').description('get the Cpp.js system configuration');
+commandConfig.command('set').description('set the Cpp.js system configuration');
+commandConfig.command('delete').description('delete the Cpp.js system configuration');
+const commandConfigList = commandConfig.command('list').description('list the Cpp.js configurations')
+    .addOption(new Option('-t, --type <type>', 'config type').default('system').choices(['all', 'system', 'project']));
+commandConfig.command('keys').description('list all available system configuration keys for Cpp.js');
 
 program.parse(process.argv);
 
 switch (program.args[0]) {
     case 'build': {
         const { platform } = commandBuild.opts();
-        build(platform);
+        if (state.config.build) {
+            buildExternal(platform);
+        } else {
+            build(platform);
+        }
         break;
     }
-    case 'run': {
-        const [programName, ...params] = commandRun.args;
-        run(programName, params);
+    case 'docker': {
+        switch (program.args[1]) {
+            case 'run': {
+                const [programName, ...params] = commandRun.args;
+                run(programName, params);
+                break;
+            }
+            case 'create': {
+                const args = [
+                    'run',
+                    '-dit',
+                    '--name',
+                    `${getDockerImage()}-${getContentHash(state.config.paths.base)}`.replace('/', '-').replace(':', '-'),
+                    '-v', `${state.config.paths.base}:/tmp/cppjs/live`,
+                    getDockerImage(),
+                    'bash',
+                ];
+                try {
+                    execFileSync('docker', args, { stdio: 'inherit' });
+                } catch (e) {
+                    console.error('An error occurred while running the application. Please check the logs for more details.');
+                    process.exit();
+                }
+                break;
+            }
+            case 'start': {
+                const args = [
+                    'start',
+                    `${getDockerImage()}-${getContentHash(state.config.paths.base)}`.replace('/', '-').replace(':', '-'),
+                ];
+                try {
+                    execFileSync('docker', args, { stdio: 'inherit' });
+                } catch (e) {
+                    console.error('An error occurred while running the application. Please check the logs for more details.');
+                    process.exit();
+                }
+                break;
+            }
+            case 'stop': {
+                const args = [
+                    'stop',
+                    `${getDockerImage()}-${getContentHash(state.config.paths.base)}`.replace('/', '-').replace(':', '-'),
+                ];
+                try {
+                    execFileSync('docker', args, { stdio: 'inherit' });
+                } catch (e) {
+                    console.error('An error occurred while running the application. Please check the logs for more details.');
+                    process.exit();
+                }
+                break;
+            }
+            case 'delete': {
+                const args = [
+                    'rm',
+                    `${getDockerImage()}-${getContentHash(state.config.paths.base)}`.replace('/', '-').replace(':', '-'),
+                ];
+                try {
+                    execFileSync('docker', args, { stdio: 'inherit' });
+                } catch (e) {
+                    console.error('An error occurred while running the application. Please check the logs for more details.');
+                    process.exit();
+                }
+                break;
+            }
+            default:
+        }
         break;
     }
-    case 'postinstall': {
-        postInstall();
+    case 'config': {
+        switch (program.args[1]) {
+            case 'get':
+                getSystemConfig(program.args[2]);
+                break;
+            case 'set':
+                setSystemConfig(program.args[2], program.args[3]);
+                break;
+            case 'delete':
+                deleteSystemConfig(program.args[2]);
+                break;
+            case 'list':
+                listSystemConfig(commandConfigList.opts().type);
+                break;
+            case 'keys':
+                listSystemKeys();
+                break;
+            default:
+                break;
+        }
         break;
     }
     default:
         break;
 }
 
-function postInstall() {
-    const projectPath = process.env.PWD;
-    const isDarwin = process.platform === 'darwin';
-    if (
-        !isDarwin
-        || (
-            !fs.existsSync(`${projectPath}/cppjs.config.js`)
-            && !fs.existsSync(`${projectPath}/cppjs.config.cjs`)
-            && !fs.existsSync(`${projectPath}/cppjs.config.mjs`)
-        )
-    ) {
+function listSystemKeys() {
+    console.info('Available configurations:');
+    console.table(systemKeys);
+}
+
+function getSystemConfig(systemKey) {
+    if (!systemKey) {
+        listSystemConfig('system');
         return;
     }
+    const key = systemKey.toUpperCase();
+    const output = {};
+    if (key in state.config.system) {
+        output[key] = { value: state.config.system[key] || 'undefined', default: systemKeys[key].default };
+    }
+    Object.keys(systemKeys).filter((k) => k.includes(key)).forEach((k) => {
+        if (k in state.config.system) {
+            output[k] = { value: state.config.system[k] || 'undefined', default: systemKeys[k].default };
+        }
+    });
 
-    const cppjs = new CppjsCompiler();
-    const name = cppjs?.config?.general?.name;
-    let dist = cppjs?.config?.paths?.output;
-    dist = dist ? getPathInfo(dist, projectPath).relative : null;
+    console.table(output);
+}
 
-    if (!name || !dist) {
-        return;
+function setSystemConfig(key, value) {
+    if (!systemKeys[key]) {
+        throw new Error(`Configuration ${key} is not available. Please choose from the following available configurations: ${Object.keys(systemKeys).join(', ')}`);
+    }
+    if (systemKeys[key].options && !systemKeys[key].options.includes(value)) {
+        throw new Error(`Value ${value} is not available. Please choose from the following available values: ${systemKeys[key].options.join(', ')}`);
     }
 
-    cppjs?.config?.export?.libName?.forEach((fileName) => {
-        if (fs.existsSync(`${projectPath}/${fileName}.xcframework`) || !fs.existsSync(`${dist}/prebuilt/${fileName}.xcframework`)) {
-            return;
-        }
-        fs.symlinkSync(`${dist}/prebuilt/${fileName}.xcframework`, `${projectPath}/${fileName}.xcframework`);
-    });
+    state.config.system[key] = value;
+    writeJson(state.config.paths.systemConfig, state.config.system);
 }
 
-function run(programName, params) {
-    const compiler = new CppjsCompiler();
-    compiler.run(programName, params, { console: true });
+function deleteSystemConfig(key) {
+    if (!systemKeys[key]) {
+        throw new Error(`Configuration ${key} is not available. Please choose from the following available configurations: ${Object.keys(systemKeys).join(', ')}`);
+    }
+    delete state.config.system[key];
+    writeJson(state.config.paths.systemConfig, state.config.system);
 }
 
-function build(platform) {
-    const compiler2 = new CppjsCompiler();
+function listSystemConfig(type) {
+    const { system: systemConfig, ...projectConfig } = state.config;
+    if (type === 'all' || type === 'system') {
+        console.log('System Configuration');
+        console.table(systemConfig);
+    }
 
-    const modules = [];
-    compiler2.config.paths.module.forEach((modulePath) => {
-        modules.push(...glob.sync('**/*.i', { absolute: true, cwd: modulePath }));
-        modules.push(...glob.sync('*.i', { absolute: true, cwd: modulePath }));
-    });
+    if (type === 'all') {
+        console.log('');
+    }
 
-    if (platform === 'all' || platform === 'wasm') {
-        if (!fs.existsSync(`${compiler2.config.paths.output}/prebuilt/Emscripten-x86_64`)) {
-            buildWasm();
-            modules.forEach((modulePath) => {
-                const fileName = modulePath.split('/').at(-1);
-                createDir('prebuilt/Emscripten-x86_64/swig', compiler2.config.paths.output);
-                fs.copyFileSync(modulePath, `${compiler2.config.paths.output}/prebuilt/Emscripten-x86_64/swig/${fileName}`);
+    if (type === 'all' || type === 'project') {
+        console.log('Project Configuration');
+        console.table(projectConfig);
+    }
+}
+
+function run(programName, params) {
+    runCppjsApp(programName, params, null, null, { console: true });
+}
+
+async function buildExternal(platform) {
+    const version = state.config.package.nativeVersion;
+    if (!version) {
+        console.error('no version found!');
+        return;
+    }
+
+    const { getURL, replaceList, copyToSource } = state.config.build;
+    const isNewlyCreated = await downloadAndExtractFile(getURL(version), state.config.paths.build);
+    const sourcePath = `${state.config.paths.build}/source`;
+    if (isNewlyCreated && replaceList) {
+        replaceList.forEach(({ regex, replacement, paths }) => {
+            replace({
+                regex, replacement, paths: paths.map((p) => `${sourcePath}/${p}`), recursive: false, silent: true,
             });
-        }
+        });
     }
 
-    if (platform === 'wasm') return;
-    const platforms = {
-        all: ['Android-arm64-v8a', 'iOS-iphoneos', 'iOS-iphonesimulator'],
-        android: ['Android-arm64-v8a'],
-        ios: ['iOS-iphoneos', 'iOS-iphonesimulator'],
-    };
-    platforms[platform].forEach((p) => {
-        if (!fs.existsSync(`${compiler2.config.paths.output}/prebuilt/${p}`)) {
-            const compiler = new CppjsCompiler(p);
-            compiler.createLib();
+    if (isNewlyCreated && copyToSource) {
+        Object.entries(copyToSource).forEach(([key, value]) => {
+            fs.copyFileSync(`${state.config.paths.project}/${key}`, `${sourcePath}/${value}`);
+        });
+    }
+
+    buildLib(platform);
+}
+
+async function build(platform) {
+    buildLib(platform);
+    if (platform === 'WebAssembly' || platform === 'All') {
+        createWasmJs();
+    }
+}
+
+function buildLib(platform) {
+    state.platforms[platform].forEach((p) => {
+        if (!fs.existsSync(`${state.config.paths.output}/prebuilt/${p}/lib`)) {
+            createLib(p, 'Source', { isProd: true, buildSource: true });
+
+            const modules = [];
+            state.config.paths.module.forEach((modulePath) => {
+                modules.push(...findFiles('**/*.i', { cwd: modulePath }));
+                modules.push(...findFiles('*.i', { cwd: modulePath }));
+            });
+            if (modules.length > 0) {
+                fs.mkdirSync(`${state.config.paths.output}/prebuilt/${p}/swig`, { recursive: true });
+            }
             modules.forEach((modulePath) => {
                 const fileName = modulePath.split('/').at(-1);
-                createDir(`prebuilt/${p}/swig`, compiler2.config.paths.output);
-                fs.copyFileSync(modulePath, `${compiler2.config.paths.output}/prebuilt/${p}/swig/${fileName}`);
+                fs.copyFileSync(modulePath, `${state.config.paths.output}/prebuilt/${p}/swig/${fileName}`);
             });
+        } else {
+            console.log(`${state.config.general.name} is already compiled to ${p} architecture.`);
         }
     });
-    if (platform === 'all' || platform === 'ios') {
-        compiler2.finishBuild();
-    }
 
-    const distCmakeContent = fs.readFileSync(`${compiler2.config.paths.cli}/assets/dist.cmake`, { encoding: 'utf8', flag: 'r' })
-        .replace('___PROJECT_NAME___', compiler2.config.general.name).replace('___PROJECT_LIBS___', compiler2.config.export.libName.join(';'));
-    fs.writeFileSync(`${compiler2.config.paths.output}/prebuilt/CMakeLists.txt`, distCmakeContent);
+    fs.cpSync(`${state.config.paths.build}/Source-Release/prebuilt`, `${state.config.paths.output}/prebuilt`, { recursive: true, dereference: true });
+
+    createXCFramework();
+
+    const distCmakeContent = fs.readFileSync(`${state.config.paths.cli}/assets/dist.cmake`, { encoding: 'utf8', flag: 'r' })
+        .replace('___PROJECT_NAME___', state.config.general.name).replace('___PROJECT_LIBS___', state.config.export.libName.join(';'));
+    fs.writeFileSync(`${state.config.paths.output}/prebuilt/CMakeLists.txt`, distCmakeContent);
 }
 
-async function buildWasm() {
+async function createWasmJs() {
     let headers = [];
-
-    const compiler = new CppjsCompiler();
-    compiler.config.paths.header.forEach((headerPath) => {
-        headers.push(glob.sync('**/*.h', { absolute: true, cwd: headerPath }));
+    state.config.paths.header.forEach((headerPath) => {
+        headers.push(findFiles('**/*.h', { cwd: headerPath }));
     });
     headers = headers.filter((path) => !!path.toString()).flat();
 
+    const bridges = [];
     headers.forEach((header) => {
-        compiler.findOrCreateInterfaceFile(header);
+        const bridgePath = createBridgeFile(header);
+        bridges.push(bridgePath);
     });
 
-    compiler.createBridge();
-    await compiler.createWasm({ cc: ['-O3'] });
-    createDir('prebuilt/Emscripten-x86_64/lib', compiler.config.paths.output);
+    const opt = {
+        isProd: true,
+        buildSource: false,
+        nativeGlob: [
+            `${state.config.paths.cli}/assets/commonBridges.cpp`,
+            ...bridges,
+        ],
+    };
+    createLib('Emscripten-x86_64', 'Bridge', opt);
 
-    fs.renameSync(`${compiler.config.paths.temp}/lib/lib${compiler.config.general.name}.a`, `${compiler.config.paths.output}/prebuilt/Emscripten-x86_64/lib/lib${compiler.config.general.name}.a`);
-    fs.renameSync(`${compiler.config.paths.temp}/include/`, `${compiler.config.paths.output}/prebuilt/Emscripten-x86_64/include`);
+    await buildWasm('browser', true);
+    await buildWasm('node', true);
 
-    fs.rmSync(`${compiler.config.paths.output}/data`, { recursive: true, force: true });
-    if (fs.existsSync(`${compiler.config.paths.temp}/data`)) {
-        fs.renameSync(`${compiler.config.paths.temp}/data`, `${compiler.config.paths.output}/data`);
+    fs.rmSync(`${state.config.paths.output}/data`, { recursive: true, force: true });
+    if (fs.existsSync(`${state.config.paths.build}/data`)) {
+        fs.renameSync(`${state.config.paths.build}/data`, `${state.config.paths.output}/data`);
     }
 
-    fs.copyFileSync(`${compiler.config.paths.temp}/${compiler.config.general.name}.node.js`, `${compiler.config.paths.output}/${compiler.config.general.name}.node.js`);
-    fs.copyFileSync(`${compiler.config.paths.temp}/${compiler.config.general.name}.browser.js`, `${compiler.config.paths.output}/${compiler.config.general.name}.browser.js`);
-    fs.copyFileSync(`${compiler.config.paths.temp}/${compiler.config.general.name}.wasm`, `${compiler.config.paths.output}/${compiler.config.general.name}.wasm`);
-    if (fs.existsSync(`${compiler.config.paths.temp}/${compiler.config.general.name}.data.txt`)) {
-        fs.copyFileSync(`${compiler.config.paths.temp}/${compiler.config.general.name}.data.txt`, `${compiler.config.paths.output}/${compiler.config.general.name}.data.txt`);
+    fs.copyFileSync(`${state.config.paths.build}/${state.config.general.name}.node.js`, `${state.config.paths.output}/${state.config.general.name}.node.js`);
+    fs.copyFileSync(`${state.config.paths.build}/${state.config.general.name}.browser.js`, `${state.config.paths.output}/${state.config.general.name}.browser.js`);
+    fs.copyFileSync(`${state.config.paths.build}/${state.config.general.name}.wasm`, `${state.config.paths.output}/${state.config.general.name}.wasm`);
+    if (fs.existsSync(`${state.config.paths.build}/${state.config.general.name}.data.txt`)) {
+        fs.copyFileSync(`${state.config.paths.build}/${state.config.general.name}.data.txt`, `${state.config.paths.output}/${state.config.general.name}.data.txt`);
     }
-
-    fs.rmSync(compiler.config.paths.temp, { recursive: true, force: true });
 }

package/src/index.js

@@ -1,63 +1,13 @@
-import createBridge from './functions/createBridge.js';
-import findOrCreateInterfaceFile from './functions/findOrCreateInterfaceFile.js';
-import run from './functions/run.js';
-import finishBuild from './functions/finishBuild.js';
-import getCmakeParams from './functions/getCmakeParams.js';
-import getData from './functions/getData.js';
-import createWasm from './functions/createWasm.js';
-import createLib from './functions/createLib.js';
-import getConfig from './utils/getConfig.js';
-
-const platforms = ['Emscripten-x86_64', 'Android-arm64-v8a', 'iOS-iphoneos', 'iOS-iphonesimulator'];
-export default class CppjsCompiler {
-    constructor(platform) {
-        this.config = getConfig();
-        this.interfaces = [];
-        this.platform = platform;
-    }
-
-    findOrCreateInterfaceFile(path) {
-        return findOrCreateInterfaceFile(this, path);
-    }
-
-    createBridge() {
-        return createBridge(this);
-    }
-
-    createWasm(options) {
-        return createWasm(this, options);
-    }
-
-    createLib() {
-        return createLib(this);
-    }
-
-    getCmakeParams() {
-        return getCmakeParams(this.config, null, true, true);
-    }
-
-    getData(field, prefixPath, subPlatform) {
-        return getData(this.config, field, prefixPath, this.platform, subPlatform);
-    }
-
-    run(program, params, dockerOptions) {
-        run(this, program, params, dockerOptions);
-    }
-
-    finishBuild() {
-        finishBuild(this);
-    }
-
-    // eslint-disable-next-line class-methods-use-this
-    getAllPlatforms() {
-        return platforms;
-    }
-}
-
-export function initCppJs() {
-    return new Promise((resolve) => {
-        resolve();
-    });
-}
-
-export const Native = {};
+// eslint-disable-next-line import/prefer-default-export
+export { default as state } from './state/index.js';
+export { default as getParentPath } from './utils/getParentPath.js';
+export { default as createLib } from './actions/createLib.js';
+export { default as createBridgeFile } from './actions/createInterface.js';
+export { default as buildWasm } from './actions/buildWasm.js';
+export { default as getData } from './actions/getData.js';
+export { default as getCmakeParameters } from './actions/getCmakeParameters.js';
+export { default as createXCFramework } from './actions/createXCFramework.js';
+export { default as getAllBridges } from './actions/getAllBridges.js';
+export { default as run } from './actions/run.js';
+export { default as getCppJsScript } from './integration/getCppJsScript.js';
+export { default as getDependFilePath } from './integration/getDependFilePath.js';

package/src/integration/getCppJsScript.js

@@ -0,0 +1,91 @@
+import getData from '../actions/getData.js';
+import loadJson from '../utils/loadJson.js';
+import state from '../state/index.js';
+
+export default function getCppJsScript(platform, bridgePath = null) {
+    if (!platform || !state.platforms.All.includes(platform)) {
+        throw new Error('The platform is not available!');
+    }
+    const env = JSON.stringify(getData('env', platform));
+    const getPlatformScript = state.platforms.WebAssembly.includes(platform) ? getWebScript : getReactNativeScript;
+
+    const bridgeExportFile = `${bridgePath}.exports.json`;
+    let symbols = null;
+    if (bridgePath) {
+        symbols = loadJson(bridgeExportFile);
+    }
+
+    let symbolExportDefineString = '';
+    let symbolExportAssignString = '';
+    if (symbols && Array.isArray(symbols)) {
+        symbolExportDefineString = symbols.map((s) => `export let ${s} = null;`).join('\n');
+        symbolExportAssignString = symbols.map((s) => `${s} = m.${s};`).join('\n');
+    }
+
+    const scriptContent = `
+        AllSymbols = m;
+        ${symbolExportAssignString}
+    `;
+
+    return `
+        export let AllSymbols = {};
+        ${symbolExportDefineString}
+        ${getPlatformScript(env, scriptContent)}
+    `;
+}
+
+function getReactNativeScript(env, modulePrefix) {
+    return `
+        import { NativeModules } from 'react-native';
+        import Module from '@cpp.js/core-embind-jsi';
+
+        const { RNJsiLib } = NativeModules;
+
+        function setEnv() {
+            const env = JSON.parse('${env}');
+            const CPPJS_DATA_PATH = Module.CppJS.getEnv('CPPJS_DATA_PATH');
+
+            Object.entries(env).forEach(([key, value]) => {
+                Module.CppJS.setEnv(key, value.replace('_CPPJS_DATA_PATH_', CPPJS_DATA_PATH), true);
+            });
+        }
+
+        export function initCppJs(config = {}) {
+            return new Promise((resolve, reject) => {
+                if (RNJsiLib && RNJsiLib.start) {
+                    RNJsiLib.start();
+                    setEnv();
+                    const m = Module;
+                    ${modulePrefix}
+                    resolve(Module);
+                } else {
+                    reject('Module failed to initialise.');
+                }
+            });
+        }
+    `;
+}
+
+function getWebScript(env, modulePrefix) {
+    const params = `{
+        ...config,
+        env: {...${env}, ...config.env},
+        paths: {
+            wasm: 'cpp.wasm',
+            data: 'cpp.data.txt'
+        }
+    }`;
+
+    return `
+        export function initCppJs(config = {}) {
+            return new Promise((resolve, reject) => {
+                import(/* webpackIgnore: true */ '/cpp.js').then(n => {
+                    return window.CppJs.initCppJs(${params});
+                }).then(m => {
+                    ${modulePrefix}
+                    resolve(m);
+                });
+            });
+        }
+    `;
+}

package/src/integration/getDependFilePath.js

@@ -0,0 +1,34 @@
+import fs from 'node:fs';
+import state from '../state/index.js';
+
+export default function getDependFilePath(source, platform) {
+    const headerRegex = new RegExp(`\\.(${state.config.ext.header.join('|')})$`);
+    const moduleRegex = new RegExp(`\\.(${state.config.ext.module.join('|')})$`);
+
+    const dependPackage = state.config.allDependencies.find((d) => source.startsWith(d.package.name));
+    if (dependPackage) {
+        const depName = dependPackage.package.name;
+        const filePath = source.substring(depName.length + 1);
+
+        let path;
+        if (headerRegex.test(source)) {
+            path = `${dependPackage.paths.output}/prebuilt/${platform}/include`;
+        } else if (moduleRegex.test(source)) {
+            path = `${dependPackage.paths.output}/prebuilt/${platform}/swig`;
+        } else {
+            path = `${dependPackage.paths.output}/prebuilt/${platform}`;
+        }
+
+        if (fs.existsSync(`${path}/${depName}/${filePath}`)) {
+            path = `${path}/${depName}/${filePath}`;
+        } else if (fs.existsSync(`${path}/${filePath}`)) {
+            path = `${path}/${filePath}`;
+        } else {
+            throw new Error(`${source} not found in ${depName} package.`);
+        }
+
+        return path;
+    }
+
+    return null;
+}