cpp.js 0.6.1 → 1.0.0-alpha.3

package/src/assets/node.js

@@ -0,0 +1,130 @@
+/* eslint-disable import/no-unresolved */
+/* eslint-disable import/first */
+/* eslint-disable no-restricted-syntax */
+/* eslint-disable no-undef */
+
+import Module from 'cpp.js/module';
+import systemConfig from 'cpp.js/systemConfig';
+
+let cppJsPromise;
+
+function isObject(item) {
+    return (item && typeof item === 'object' && !Array.isArray(item));
+}
+
+function mergeDeep(target, ...sources) {
+    if (!sources.length) return target;
+    const source = sources.shift();
+
+    if (isObject(target) && isObject(source)) {
+        for (const key in source) {
+            if (isObject(source[key])) {
+                if (!target[key]) Object.assign(target, { [key]: {} });
+                mergeDeep(target[key], source[key]);
+            } else {
+                Object.assign(target, { [key]: source[key] });
+            }
+        }
+    }
+
+    return mergeDeep(target, ...sources);
+}
+
+function initCppJs(userConfig = {}) {
+    if (cppJsPromise) return cppJsPromise;
+
+    const config = mergeDeep(systemConfig, userConfig);
+    Object.entries(config.env).forEach(([key, value]) => config.env[key] = value.replace('_CPPJS_DATA_PATH_', `${__dirname}/data`));
+
+    cppJsPromise = new Promise((resolve, reject) => {
+        const m = {
+            print(text) {
+                if (config.logHandler) {
+                    config.logHandler(text, 'stdout');
+                } else {
+                    console.debug(`wasm stdout: ${text}`);
+                }
+            },
+            printErr(text) {
+                if (config.errorHandler) {
+                    config.errorHandler(text, 'stderr');
+                } else {
+                    console.error(`wasm stderr: ${text}`);
+                }
+            },
+            locateFile(fileName) {
+                let path = fileName;
+                if (config.paths && config.paths.wasm && fileName.endsWith('.wasm')) {
+                    path = config.paths.wasm;
+                } else if (config.paths && config.paths.data && (fileName.endsWith('.data.txt') || fileName.endsWith('.data'))) {
+                    path = config.paths.data;
+                }
+
+                let prefix = '';
+                if (config.path) {
+                    prefix = config.path;
+                    if (prefix.slice(-1) !== '/') prefix += '/';
+                } else {
+                    prefix = `${__dirname}/`;
+                }
+
+                let output = prefix + path;
+                if (output.endsWith('.data')) output += '.txt';
+                return output;
+            },
+
+            preRun: [
+                ({ ENV }) => {
+                    if (ENV && config && config.env) {
+                        Object.entries(config.env).forEach(([key, value]) => {
+                            // eslint-disable-next-line no-param-reassign
+                            ENV[key] = value;
+                        });
+                    }
+                },
+            ],
+            onRuntimeInitialized() {
+                if (config.onRuntimeInitialized) config.onRuntimeInitialized(m);
+            },
+            getPreloadedPackage(packageName) {
+                // eslint-disable-next-line global-require
+                const a = require('fs').readFileSync(`./${packageName}`, { flag: 'r' }).buffer;
+                return a;
+            },
+            getFileBytes(path) {
+                if (!path) return new Uint8Array();
+                return m.FS.readFile(path, { encoding: 'binary' });
+            },
+            getFileList(path = 'virtual') {
+                const contents = path.split('/').reduce((accumulator, currentValue) => accumulator.contents[currentValue], m.FS.root).contents;
+                const fileList = [];
+                Object.keys(contents).forEach((name) => {
+                    const obj = contents[name];
+                    if (obj.usedBytes) fileList.push({ path: `/${path}/${name}`, size: obj.usedBytes });
+                    else if (obj.contents) fileList.push(...m.getFileList(`${path}/${name}`));
+                });
+                return fileList;
+            },
+
+            toArray(vector) {
+                const output = [];
+                for (let i = 0; i < vector.size(); i += 1) {
+                    output.push(vector.get(i));
+                }
+                return output;
+            },
+            toVector(VectorClass, array = []) {
+                const vector = new VectorClass();
+                array.forEach((item) => {
+                    vector.push_back(item);
+                });
+                return vector;
+            },
+        };
+        Module(m).then(resolve).catch(reject);
+    });
+
+    return cppJsPromise;
+}
+
+export default initCppJs;

package/src/bin.js

@@ -4,65 +4,140 @@ import { Command, Argument } from 'commander';
 import fs from 'fs';
 import glob from 'glob';
 import { createDir } from './utils/createTempDir.js';
-
-const packageJSON = JSON.parse(fs.readFileSync(new URL('../package.json', import.meta.url)));
+import getPathInfo from './utils/getPathInfo.js';
 
 import CppjsCompiler from './index.js';
 
+const packageJSON = JSON.parse(fs.readFileSync(new URL('../package.json', import.meta.url)));
+
 const program = new Command();
 
 program
-  .name('cpp.js')
-  .description('Compile c++ files to webassembly.')
-  .version(packageJSON.version)
-  .showHelpAfterError();
+    .name('cpp.js')
+    .description('Compile c++ files to webassembly.')
+    .version(packageJSON.version)
+    .showHelpAfterError();
 
 const commandGenerate = program.command('generate')
-  .description('Generate app or lib.')
-  .addArgument(new Argument('<type>', 'Generation type').choices(['app', 'lib']))
-  .option('-b, --base <base>', 'base path')
-  .option('-p, --platform <platform>', 'platform (wasm)', 'wasm', ['wasm'])
-  .option('-o, --output <string>', 'Output path');
+    .description('Generate app or lib.')
+    .addArgument(new Argument('<type>', 'Generation type').choices(['app', 'lib']))
+    .option('-b, --base <base>', 'base path')
+    .option('-p, --platform <platform>', 'platform (all)', 'all', ['all', 'wasm', 'android', 'ios'])
+    .option('-o, --output <string>', 'Output path');
+
+const commandRun = program.command('run')
+    .description('Run docker application');
+
+const commandPostInstall = program.command('postinstall')
+    .description('npm postinstall');
 
 program.parse(process.argv);
 
 switch (program.args[0]) {
-    case 'generate':
+    case 'generate': {
         const type = commandGenerate.args[0];
         const { output, platform, base } = commandGenerate.opts();
         generate(type, platform, output, base);
         break;
+    }
+    case 'run': {
+        const [programName, ...params] = commandRun.args;
+        run(programName, params);
+        break;
+    }
+    case 'postinstall': {
+        postInstall();
+        break;
+    }
     default:
         break;
 }
 
-function generate(type, platform, output, base) {
-    if (type === 'lib') generateLib(platform, output, base);
+function postInstall() {
+    const projectPath = process.env.PWD;
+    if (!fs.existsSync(`${projectPath}/cppjs.config.js`) && !fs.existsSync(`${projectPath}/cppjs.config.cjs`) && !fs.existsSync(`${projectPath}/cppjs.config.mjs`)) {
+        return;
+    }
+
+    const cppjs = new CppjsCompiler();
+    const name = cppjs?.config?.general?.name;
+    let dist = cppjs?.config?.paths?.output;
+    dist = dist ? getPathInfo(dist, projectPath).relative : null;
+
+    if (!name || !dist) {
+        return;
+    }
+
+    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`);
+    });
+}
+
+function run(programName, params) {
+    const compiler = new CppjsCompiler();
+    compiler.run(programName, params);
 }
 
-function generateLib(platform, output, base) {
+function generate(type, platform) {
+    const compiler2 = new CppjsCompiler();
+    if (type === 'lib') {
+        if (platform === 'all' || platform === 'wasm') {
+            if (!fs.existsSync(`${compiler2.config.paths.output}/prebuilt/Emscripten-x86_64`)) {
+                generateWasmLib();
+            }
+        }
+        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 (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);
+}
+
+async function generateWasmLib() {
     let headers = [];
 
     const compiler = new CppjsCompiler();
-    compiler.config.paths.header.forEach(headerPath => {
-        headers.push(glob.sync("**/*.h", { absolute: true, cwd: headerPath }));
+    compiler.config.paths.header.forEach((headerPath) => {
+        headers.push(glob.sync('**/*.h', { absolute: true, cwd: headerPath }));
     });
-    headers = headers.filter(path => !!path.toString()).flat();
+    headers = headers.filter((path) => !!path.toString()).flat();
 
-    headers.forEach(header => {
+    headers.forEach((header) => {
         compiler.findOrCreateInterfaceFile(header);
     });
 
     compiler.createBridge();
-    compiler.createWasm({ cc: ['-O3'] });
-    createDir('prebuilt', compiler.config.paths.output);
-    fs.copyFileSync(`${compiler.config.paths.temp}/${compiler.config.general.name}.js`, `${compiler.config.paths.output}/${compiler.config.general.name}.js`);
+    await compiler.createWasm({ cc: ['-O3'] });
+    createDir('prebuilt/Emscripten-x86_64', compiler.config.paths.output);
+    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`);
-    fs.rmSync(`${compiler.config.paths.output}/prebuilt`, { recursive: true, force: true });
-    fs.renameSync(`${compiler.config.paths.temp}/prebuilt`, `${compiler.config.paths.output}/prebuilt`);
+    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.renameSync(`${compiler.config.paths.temp}/lib/`, `${compiler.config.paths.output}/prebuilt/Emscripten-x86_64/lib`);
+    fs.renameSync(`${compiler.config.paths.temp}/include/`, `${compiler.config.paths.output}/prebuilt/Emscripten-x86_64/include`);
 
-    const distCmakeContent = fs.readFileSync(`${compiler.config.paths.cli}/assets/dist.cmake`, { encoding: 'utf8', flag: 'r' })
-        .replace('___PROJECT_NAME___', compiler.config.general.name);
-    fs.writeFileSync(`${compiler.config.paths.output}/prebuilt/CMakeLists.txt`, distCmakeContent);
+    fs.rmSync(`${compiler.config.paths.output}/data`, { recursive: true, force: true });
+    fs.renameSync(`${compiler.config.paths.temp}/data`, `${compiler.config.paths.output}/data`);
     fs.rmSync(compiler.config.paths.temp, { recursive: true, force: true });
 }

package/src/functions/buildJS.js

@@ -0,0 +1,63 @@
+/* eslint-disable no-await-in-loop */
+/* eslint-disable no-restricted-syntax */
+import fs from 'fs';
+import { rollup } from 'rollup';
+import { nodeResolve } from '@rollup/plugin-node-resolve';
+import commonjs from '@rollup/plugin-commonjs';
+import virtual from '@rollup/plugin-virtual';
+
+const nodeLibs = {
+    fs: 'export default {};',
+    path: 'export default {};',
+    string_decoder: 'export default {};',
+    buffer: 'export default {};',
+    crypto: 'export default {};',
+    stream: 'export default {};',
+};
+
+const options = {
+    browser: {
+        plugins: [virtual(nodeLibs), nodeResolve(), commonjs({ transformMixedEsModules: true, ignoreTryCatch: 'remove' })],
+        output: {
+            file: 'browser',
+            format: 'umd',
+            name: 'initCppJs',
+        },
+    },
+    node: {
+        plugins: [nodeResolve(), commonjs()],
+        output: {
+            file: 'node',
+            format: 'umd',
+            name: 'initCppJs',
+        },
+    },
+};
+
+export default async function buildJS(compiler, input, type) {
+    const entryJS = `${compiler.config.paths.cli}/assets/${type}.js`;
+    const env = JSON.stringify(compiler.getData('env', null, type));
+    const systemConfig = `export default {
+        env: ${env},
+        paths: {
+            wasm: '${compiler.config.general.name}.wasm',
+            data: '${compiler.config.general.name}.data.txt'
+        }
+    }`;
+    let file = input;
+    if (input.endsWith('.js')) {
+        file = input.substring(0, input.length - 3);
+    }
+    // fs.renameSync(input, `${input}.raw.js`);
+    const option = options[type];
+    option.plugins = [virtual({
+        'cpp.js/systemConfig': systemConfig,
+        'cpp.js/module': `export { default } from '${input}';`,
+    }), ...option.plugins];
+    option.input = entryJS;
+    option.output.file = `${file}.${option.output.file}.js`;
+    const bundle = await rollup(option);
+    await bundle.write(option.output);
+    // fs.rmSync(`${input}.raw.js`, { force: true });
+}
+//

package/src/functions/createBridge.js

@@ -1,32 +1,31 @@
 import glob from 'glob';
-import { execFileSync } from 'child_process';
-import pullDockerImage, { getDockerImage } from '../utils/pullDockerImage.js';
 import getBaseInfo from '../utils/getBaseInfo.js';
 import getPathInfo from '../utils/getPathInfo.js';
-import getOsUserAndGroupId from '../utils/getOsUserAndGroupId.js';
+import run from './run.js';
 
-export default function createBridge(compiler) {
-    pullDockerImage();
+const platform = 'Emscripten-x86_64';
 
+export default function createBridge(compiler) {
     const bridges = [];
-    compiler.interfaces.forEach(filePath => {
+    compiler.interfaces.forEach((filePath) => {
         const input = getPathInfo(filePath, compiler.config.paths.base);
-        const output = getPathInfo(compiler.config.paths.temp+'/bridge', compiler.config.paths.base);
-        const projectPath = getPathInfo(compiler.config.paths.project, compiler.config.paths.base);
+        const output = getPathInfo(`${compiler.config.paths.temp}/bridge`, compiler.config.paths.base);
         const base = getBaseInfo(compiler.config.paths.base);
 
         const includePath = [
-            ...glob.sync("node_modules/cppjs-lib-*/include", { absolute: true, cwd: compiler.config.paths.project }),
-            ...glob.sync("node_modules/cppjs-lib-*/node_modules/cppjs-lib-*/include", { absolute: true, cwd: compiler.config.paths.project }),
+            ...compiler.config.getAllDependencies().map((d) => `${d.paths.output}/prebuilt/${platform}/include`),
+            ...compiler.config.getAllDependencies().map((d) => `${d.paths.output}/prebuilt/${platform}/swig`),
             ...compiler.config.paths.header,
-        ].filter(path => !!path.toString()).map(path => `-I/live/${getPathInfo(path, compiler.config.paths.base).relative}`);
+        ].filter((path) => !!path.toString()).map((path) => `-I/tmp/cppjs/live/${getPathInfo(path, compiler.config.paths.base).relative}`);
+
+        run(compiler, 'swig', [
+            '-c++',
+            '-embind',
+            '-o', `/tmp/cppjs/live/${output.relative}/${filePath.split('/').at(-1)}.cpp`,
+            ...includePath,
+            `/tmp/cppjs/live/${input.relative}`,
+        ]);
 
-        const options = { cwd: output.absolute, stdio : 'pipe' };
-        const args = [
-            "run", "--user", getOsUserAndGroupId(), "-v", `${base.withoutSlash}:/live`, getDockerImage(),
-            "swig", "-c++", '-emscripten', '-o', `/live/${output.relative}/${filePath.split('/').at(-1)}.cpp`, ...includePath, `/live/${input.relative}`
-        ];
-        execFileSync("docker", args, options);
         bridges.push(`${base.withSlash}${output.relative}/${filePath.split('/').at(-1)}.cpp`);
     });
     return bridges;

package/src/functions/createLib.js

@@ -0,0 +1,44 @@
+import fs from 'fs';
+import os from 'os';
+import getCmakeParams from './getCmakeParams.js';
+import getPathInfo from '../utils/getPathInfo.js';
+
+const cpuCount = os.cpus().length - 1;
+
+export default function createLib(compiler) {
+    if (!compiler.platform) return;
+
+    let platformParams = [];
+    switch (compiler.platform) {
+        case 'Emscripten-x86_64':
+            platformParams = ['-DBUILD_TYPE=STATIC'];
+            break;
+        case 'Android-arm64-v8a':
+            platformParams = ['-DBUILD_TYPE=SHARED'];
+            break;
+        case 'iOS-iphoneos':
+            platformParams = ['-DBUILD_TYPE=STATIC'];
+            break;
+        case 'iOS-iphonesimulator':
+            platformParams = ['-DBUILD_TYPE=STATIC'];
+            break;
+        default:
+    }
+
+    const libdir = `${getPathInfo(compiler.config.paths.output, compiler.config.paths.base).relative}/prebuilt/${compiler.platform}`;
+    const basePlatform = compiler.platform.split('-', 1)[0];
+    const params = getCmakeParams(compiler.config, '/tmp/cppjs/live/', true, false);
+    compiler.run(null, [
+        basePlatform === 'iOS' ? 'ios-cmake' : 'cmake', '/tmp/cppjs/cmake',
+        '-DCMAKE_BUILD_TYPE=Release', ...platformParams,
+        `-DCMAKE_INSTALL_PREFIX=/tmp/cppjs/live/${libdir}`, `-DPROJECT_NAME=${compiler.config.general.name}`,
+        ...params,
+    ]);
+    if (basePlatform === 'iOS') {
+        compiler.run(null, ['ios-cmake', '--build', '.', '--config', 'Release', '--target', 'install']);
+    } else {
+        compiler.run(null, ['make', `-j${cpuCount}`, 'install']);
+    }
+
+    fs.rmSync(compiler.config.paths.temp, { recursive: true, force: true });
+}