cpp.js 0.2.0 → 0.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cpp.js",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "license": "MIT",
   "type": "module",
   "bin": {

package/src/assets/CMakeLists.txt

@@ -0,0 +1,23 @@
+cmake_minimum_required(VERSION 3.1)
+project("${PROJECT_NAME}")
+
+option(BUILD_BRIDGE "Build Bridge" OFF)
+option(BUILD_SOURCE "Build Source" OFF)
+
+if(BUILD_SOURCE)
+file(GLOB BUILD_SRC_FILES "${BASE_DIR}/native/**/*.cpp" "${BASE_DIR}/native/*.cpp" "${BASE_DIR}/src/native/**/*.cpp" "${BASE_DIR}/src/native/*.cpp")
+endif(BUILD_SOURCE)
+unset(BUILD_SOURCE CACHE)
+
+message("aa", BUILD_SRC_FILES)
+
+if(BUILD_BRIDGE)
+file(GLOB BRIDGE_SRC_FILES "${BRIDGE_DIR}/*.i.cpp")
+endif(BUILD_BRIDGE)
+unset(BUILD_BRIDGE CACHE)
+
+set(SRC_FILES "${BUILD_SRC_FILES}" "${BRIDGE_SRC_FILES}")
+add_library("${PROJECT_NAME}" STATIC ${SRC_FILES})
+
+file(GLOB HEADERS "${BASE_DIR}/node_modules/cppjs-lib-*/include")
+include_directories("${HEADERS};${BASE_DIR}/native;${BASE_DIR}/src/native")

package/src/bin.js

@@ -2,38 +2,61 @@
 
 import packageJSON from '../package.json' assert { type: 'json' };
 import { Command, Argument } from 'commander';
+import fs from 'fs';
+import glob from 'glob';
+import { createDir } from './utils/createTempDir.js';
 
-import { createBridge, findCMakeListsFile, findOrCreateInterfaceFile, createWasm } from './index.js';
-import { createTempDir } from './utils.js';
+import CppjsCompiler from './index.js';
 
 const program = new Command();
-    program
-    .name('cpp.js')
-    .description('Compile c++ files to webassembly.')
-    .version(packageJSON.version)
-    .showHelpAfterError();
 
-    program.addArgument(new Argument('<type>', 'Creation type').choices(['bridge', 'wasm', 'all']));
-    program.argument('<input>', 'Input paths');
-    program
-        .option('-o, --output <string>', 'Output path');
+program
+  .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');
 
 program.parse(process.argv);
-const options = program.opts();
-const args = program.args;
-
-const [type, ...inputs]= args;
-main(type, inputs);
-
-async function main(type, inputs, output = createTempDir('a'+Math.random())) {
-    if (type === 'bridge' || type === 'all') {
-        const interfaceFile = findOrCreateInterfaceFile(process.cwd()+'/'+inputs[0], output);
-        createBridge(interfaceFile, output);
-    }
-
-    if (type === 'wasm' || type === 'all') {
-        const cMakeListsFilePath = findCMakeListsFile();
-        createWasm(cMakeListsFilePath, output, output, { cc: ['-O3'] });
-    }
-    console.log('output: ' + output);
+
+switch (program.args[0]) {
+    case 'generate':
+        const type = commandGenerate.args[0];
+        const { output, platform, base } = commandGenerate.opts();
+        generate(type, platform, output, base);
+        break;
+    default:
+        break;
+}
+
+function generate(type, platform, output, base) {
+    if (type === 'lib') generateLib(platform, output, base);
+}
+
+function generateLib(platform, output, base) {
+    let headers = [];
+
+    const compiler = new CppjsCompiler();
+    compiler.config.paths.header.forEach(headerPath => {
+        headers.push(glob.sync("*.h", { absolute: true, cwd: headerPath }));
+    });
+    headers = headers.filter(path => !!path.toString()).flat();
+
+    headers.forEach(header => {
+        compiler.findOrCreateInterfaceFile(header);
+        compiler.createBridge();
+        compiler.createWasm({ cc: ['-O3'] });
+        createDir('lib', compiler.config.paths.output);
+        fs.copyFileSync(`${compiler.config.paths.temp}/${compiler.config.general.name}.js`, `${compiler.config.paths.output}/${compiler.config.general.name}.js`);
+        fs.copyFileSync(`${compiler.config.paths.temp}/${compiler.config.general.name}.wasm`, `${compiler.config.paths.output}/${compiler.config.general.name}.wasm`);
+        fs.copyFileSync(`${compiler.config.paths.temp}/lib${compiler.config.general.name}.a`, `${compiler.config.paths.output}/lib/lib${compiler.config.general.name}.a`);
+        fs.rmSync(compiler.config.paths.temp, { recursive: true, force: true });
+    });
+
 }

package/src/functions/createBridge.js

@@ -0,0 +1,33 @@
+import glob from 'glob';
+import { execFileSync } from 'child_process';
+import pullDockerImage from '../utils/pullDockerImage.js';
+import getBaseInfo from '../utils/getBaseInfo.js';
+import getPathInfo from '../utils/getPathInfo.js';
+import getOsUserAndGroupId from '../utils/getOsUserAndGroupId.js';
+
+export default function createBridge(compiler) {
+    pullDockerImage();
+
+    const bridges = [];
+    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 base = getBaseInfo(compiler.config.paths.base);
+
+        const includePath = [
+            glob.sync("node_modules/cppjs-lib-*-web/include", { absolute: false }),
+            glob.sync("native", { absolute: false }),
+            glob.sync("src/native", { absolute: false }),
+        ].filter(path => !!path.toString()).map(path => `-I/live/${projectPath.relative}/${path}`);
+
+        const options = { cwd: output.absolute, stdio : 'pipe' };
+        const args = [
+            "run", "--user", getOsUserAndGroupId(), "-v", `${base.withoutSlash}:/live`, "bugra9/cpp.js",
+            "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/createWasm.js

@@ -0,0 +1,95 @@
+import { execFileSync } from 'child_process';
+import pullDockerImage from '../utils/pullDockerImage.js';
+import getBaseInfo from '../utils/getBaseInfo.js';
+import getPathInfo from '../utils/getPathInfo.js';
+import getOsUserAndGroupId from '../utils/getOsUserAndGroupId.js';
+
+export default function createWasm(compiler, options = {}) {
+    const compiler2 = new CppjsCompiler(
+        compiler.config.paths.cmake,
+        compiler.config.paths.output,
+        compiler.config.paths.temp,
+        compiler.config.paths.cli,
+        compiler.config.general.name,
+        options,
+        compiler.config.paths.base
+    );
+    return compiler2.compile();
+}
+
+class CppjsCompiler {
+    constructor(cMakeFilePath, outputPath, tempPath, cliPath, name, options = {}, basePath = process.cwd()) {
+        this.cMakeFilePath = cMakeFilePath;
+        this.outputPath = tempPath;
+        this.tempPath = tempPath;
+        this.cliPath = cliPath;
+        this.options = options;
+        this.basePath = basePath;
+        this.name = name;
+    }
+
+    compile() {
+        pullDockerImage();
+
+        this.cmake(this.name, true, false);
+        this.make();
+        this.cmake(this.name+'bridge', false, true);
+        this.make();
+        this.libs = [`lib${this.name}.a`, `lib${this.name}bridge.a`];
+
+        this.cc();
+
+        return this.outputPath;
+    }
+
+    cmake(name, isBuildSource, isBuildBridge) {
+        const params = [];
+        if (isBuildSource) params.push('-DBUILD_SOURCE=TRUE');
+        if (isBuildBridge) params.push('-DBUILD_BRIDGE=TRUE');
+
+        const output = getPathInfo(this.outputPath, this.basePath);
+        const projectPath = getPathInfo(process.cwd(), this.basePath);
+        const base = getBaseInfo(this.basePath);
+
+        let cMakeParentPath = this.cMakeFilePath.split('/');
+        cMakeParentPath.pop();
+        cMakeParentPath = cMakeParentPath.join('/');
+        const args = [
+            "run", "--user", getOsUserAndGroupId(), "-v", `${base.withoutSlash}:/live`, "-v", `${cMakeParentPath}:/cmake`, "--workdir", `/live/${output.relative}`, "bugra9/cpp.js",
+            "emcmake", "cmake", "/cmake", `-DBASE_DIR=/live/${projectPath.relative}`,
+            `-DCMAKE_INSTALL_PREFIX=/live/${output.relative}`, `-DBRIDGE_DIR=/live/${output.relative}/bridge`, `-DPROJECT_NAME=${name}`, ...params,
+        ];
+        const options = { cwd: this.outputPath, stdio : 'pipe' };
+        execFileSync("docker", args, options);
+        return this.outputPath;
+    }
+
+    make() {
+        const output = getPathInfo(this.outputPath, this.basePath);
+        const base = getBaseInfo(this.basePath);
+
+        let cMakeParentPath = this.cMakeFilePath.split('/');
+        cMakeParentPath.pop();
+        cMakeParentPath = cMakeParentPath.join('/');
+        const args = [
+            "run", "--user", getOsUserAndGroupId(), "-v", `${base.withoutSlash}:/live`, "-v", `${cMakeParentPath}:/cmake`, "--workdir", `/live/${output.relative}`, "bugra9/cpp.js",
+            "emmake", "make"
+        ];
+        const options = { cwd: this.outputPath, stdio : 'pipe' };
+        execFileSync("docker", args, options);
+        return this.outputPath;
+    }
+
+    cc() {
+        const input = getPathInfo(this.tempPath, this.basePath);
+        const output = getPathInfo(this.outputPath, this.basePath);
+        const base = getBaseInfo(this.basePath);
+        const args = [
+            "run", "--user", getOsUserAndGroupId(), "-v", `${base.withoutSlash}:/live`, "-v", `${this.cliPath}:/cli`, "bugra9/cpp.js",
+            "emcc", "-lembind", "-Wl,--whole-archive", ...this.libs.map(lib => `/live/${input.relative}/${lib}`), ...(this.options.cc || []), "-s", "WASM=1", "-s", "MODULARIZE=1", '-o', `/live/${output.relative}/${this.name}.js`, '--extern-post-js', '/cli/assets/extern-post.js'
+        ];
+        const options = { cwd: this.tempPath, stdio : 'pipe' };
+        execFileSync("docker", args, options);
+        return this.outputPath;
+    }
+}

package/src/{findOrCreateInterfaceFile.js → functions/findOrCreateInterfaceFile.js}

@@ -1,10 +1,11 @@
 import fs from 'fs';
-import { getBaseInfo, getPathInfo } from './utils.js';
+import getBaseInfo from '../utils/getBaseInfo.js';
+import getPathInfo from '../utils/getPathInfo.js';
 
-export default function findOrCreateInterfaceFile(filePath, outputPath, basePath = process.cwd()) {
-    const input = getPathInfo(filePath, basePath);
-    const output = getPathInfo(outputPath, basePath);
-    const base = getBaseInfo(basePath);
+export default function findOrCreateInterfaceFile(compiler, filePath) {
+    const input = getPathInfo(filePath, compiler.config.paths.base);
+    const output = getPathInfo(compiler.config.paths.temp+'/interface', compiler.config.paths.base);
+    const base = getBaseInfo(compiler.config.paths.base);
 
     const temp = input.relative.match(/^(.*)\..+?$/);
     if (temp.length < 2) return null;
@@ -33,5 +34,8 @@ export default function findOrCreateInterfaceFile(filePath, outputPath, basePath
 `;
     const outputFilePath = base.withSlash + output.relative+'/'+fileName+'.i';
     fs.writeFileSync(outputFilePath, content);
+
+    compiler.interfaces.push(outputFilePath);
+
     return outputFilePath;
 }

package/src/index.js

@@ -1,4 +1,23 @@
-export { default as createBridge } from './createBridge.js';
-export { default as findCMakeListsFile } from './findCMakeListsFile.js';
-export { default as findOrCreateInterfaceFile } from './findOrCreateInterfaceFile.js';
-export { default as createWasm } from './createWasm.js';
+import createBridge from './functions/createBridge.js';
+import findOrCreateInterfaceFile from './functions/findOrCreateInterfaceFile.js';
+import createWasm from './functions/createWasm.js';
+import getConfig from './utils/getConfig.js';
+
+export default class CppjsCompiler {
+    constructor(param) {
+        this.config = getConfig(param);
+        this.interfaces = [];
+    }
+
+    findOrCreateInterfaceFile(path) {
+        return findOrCreateInterfaceFile(this, path);
+    }
+
+    createBridge() {
+        return createBridge(this);
+    }
+
+    createWasm(options) {
+        return createWasm(this, options);
+    }
+}

package/src/utils/createTempDir.js

@@ -0,0 +1,15 @@
+import fs from 'fs';
+import p from 'path';
+
+export default function createTempDir(folder = 'a'+Math.random(), base = process.cwd()) {
+    const path = p.join(base, 'node_modules', ".cppjs");
+    return createDir(folder, path);
+}
+
+export function createDir(folder, base = process.cwd()) {
+    const path = p.join(base, folder);
+
+    if (fs.existsSync(path)) fs.rmSync(path, { recursive: true, force: true });
+    fs.mkdirSync(path, { recursive: true });
+    return path;
+}

package/src/utils/findCMakeListsFile.js

@@ -0,0 +1,12 @@
+import glob from 'glob';
+import getCliPath from './getCliPath.js';
+
+export default function findCMakeListsFile(basePath = process.cwd()) {
+    let temp = glob.sync("CMakeLists.txt", { absolute: true, cwd: basePath });
+    if (temp.length === 0) {
+        temp = glob.sync("*/CMakeLists.txt", { absolute: true, cwd: basePath, ignore: ['node_modules/*', 'dist/*', 'build/*'] });
+    }
+
+    if (temp.length > 0) return temp[0];
+    return getCliPath() + '/assets/CMakeLists.txt';
+}

package/src/utils/getBaseInfo.js

@@ -0,0 +1,15 @@
+export default function getBaseInfo(base) {
+    let basePath = base;
+
+    const output = {
+        withSlash: '/',
+        withoutSlash: '/',
+    };
+    if (basePath && basePath !== '/') {
+        if (basePath.at(-1) !== '/') basePath += '/';
+
+        output.withSlash = basePath;
+        output.withoutSlash = basePath.substring(0, basePath.length - 1);
+    }
+    return output;
+}

package/src/utils/getCliPath.js

@@ -0,0 +1,12 @@
+import {dirname} from 'path';
+import * as url from 'node:url';
+
+const __filename = url.fileURLToPath(import.meta.url);
+const temp = __filename.split('/');
+temp.pop();
+temp.pop();
+const __dirname = temp.join('/');
+
+export default function getCliPath() {
+    return __dirname;
+}

package/src/utils/getConfig.js

@@ -0,0 +1,140 @@
+import fs from 'fs';
+import createTempDir, { createDir } from './createTempDir.js';
+import findCMakeListsFile from './findCMakeListsFile.js';
+import p from 'path';
+import * as url from 'node:url';
+import { createRequire } from 'module';
+
+const __filename = url.fileURLToPath(import.meta.url);
+const temp = __filename.split('/'); temp.pop(); temp.pop();
+const __dirname = temp.join('/');
+const require = createRequire(import.meta.url);
+
+/**
+ * @typedef {Object} Config
+ * @property {string} general General
+ * @property {ConfigPaths} paths Paths
+ * @property {ConfigExtensions} extensions Extensions
+ */
+
+/**
+ * @typedef {Object} ConfigPaths
+ * @property {string} project Project path.
+ * @property {string} base Base path (Use for monorepo structure)
+ * @property {string} temp Temp path.
+ * @property {string} native Native path (default: ['native', 'src/native']).
+ * @property {string} module Module path (default: native path)
+ * @property {string} header Header path (default: native path)
+ * @property {string} bridge Bridge path (default: native and temp path)
+ * @property {string} output Output path (default: 'dist')
+ * @property {string} cmake CmakeLists.txt path
+ */
+
+/**
+ * @typedef {Object} ConfigExtensions
+ * @property {string} header Header extensions (default: ['h', 'hpp', 'hxx', 'hh'])
+ * @property {string} source Source extensions (default: ['c', 'cpp', 'cxx', 'cc'])
+ * @property {string} module Module extensions (default: ['i'])
+ */
+
+/**
+ * @typedef {Object} ConfigGeneral
+ * @property {string} name Project name
+ */
+
+export default function getConfig(param) {
+    let tempConfig = { general: {}, paths: {}, extensions: {} };
+
+    if (!param || (typeof param === 'string' || param instanceof String)) {
+        const ext = (param || '').split('.').at(-1)
+        let filePath;
+
+        if (param && ['json', 'js', 'mjs', 'cjs', 'ts'].includes(ext)) {
+            filePath = `${process.cwd()}/${param}`;
+            if (!fs.existsSync(filePath)) filePath = null;
+        } else {
+            filePath = `${process.cwd()}/.cppjs.config.json`;
+            if (!fs.existsSync(filePath)) filePath = null;
+
+            /* filePath = `${process.cwd()}/.cpp.config.js`;
+            if (!fs.existsSync(filePath)) filePath = null; */
+        }
+
+        if (filePath) {
+            const file = require(filePath);
+            if (file.default) file = file.default;
+            if (typeof file === 'function') tempConfig = file();
+            else if (typeof file === "object") tempConfig = file;
+        }
+    } else if (typeof param === "object") {
+        tempConfig = param;
+    } else {
+        console.error('Error');
+    }
+
+    return fillConfig(forceToConfigSchema(tempConfig));
+}
+
+function forceToConfigSchema(tempConfig) {
+    const config = {
+        general: tempConfig && tempConfig.general ? tempConfig.general : {},
+        paths: tempConfig && tempConfig.paths ? tempConfig.paths : {},
+        extensions: tempConfig && tempConfig.extensions ? tempConfig.extensions : {},
+    };
+    return config;
+}
+
+function getAbsolutePath(projectPath, path) {
+    if (!path) {
+        return null;
+    }
+    if (p.isAbsolute(path)) {
+        return path;
+    }
+    if (projectPath) {
+        return p.resolve(p.join(p.resolve(projectPath), path));
+    }
+    return p.resolve(path);
+}
+
+function fillConfig(tempConfig) {
+    const config = {
+        general: {},
+        paths: {
+            project: getAbsolutePath(null, tempConfig.paths.project) || process.cwd(),
+        },
+        extensions: {},
+    };
+
+    if (!config.general.name) {
+        config.general.name = 'cppjssample';
+        const packageJsonPath = `${config.paths.project}/package.json`;
+        if (fs.existsSync(packageJsonPath)) {
+            const file = JSON.parse(fs.readFileSync(packageJsonPath));
+            if (file && typeof file === 'object' && file.name){
+                config.general.name = file.name;
+            }
+        }
+    }
+
+    const getPath = getAbsolutePath.bind(null, config.paths.project);
+
+    config.paths.base = getPath(tempConfig.paths.base) || config.paths.project;
+    config.paths.temp = getPath(tempConfig.paths.temp) || createTempDir(undefined, config.paths.project)
+    config.paths.native = (tempConfig.paths.native || ['native', 'src/native']).map(p => getPath(p));
+    config.paths.module = (tempConfig.paths.module || config.paths.native).map(p => getPath(p));
+    config.paths.header = (tempConfig.paths.header || config.paths.native).map(p => getPath(p));
+    config.paths.bridge = (tempConfig.paths.bridge || [...config.paths.native, config.paths.temp]).map(p => getPath(p));
+    config.paths.output = getPath(tempConfig.paths.output) || config.paths.temp;
+    config.paths.cmake = getPath(tempConfig.paths.cmake || findCMakeListsFile(config.paths.project));
+    config.paths.cli = __dirname;
+
+    config.extensions.header = tempConfig.extensions.header || ['h', 'hpp', 'hxx', 'hh'];
+    config.extensions.source = tempConfig.extensions.source || ['c', 'cpp', 'cxx', 'cc'];
+    config.extensions.module = tempConfig.extensions.module || ['i'];
+
+    createDir('interface', config.paths.temp);
+    createDir('bridge', config.paths.temp);
+
+    return config;
+}

package/src/utils/getOsUserAndGroupId.js

@@ -0,0 +1,10 @@
+import os from "os";
+
+let osUserAndGroupId;
+export default function getOsUserAndGroupId() {
+    const userInfo = os.userInfo();
+    if (!osUserAndGroupId) {
+        osUserAndGroupId = `${userInfo.uid}:${userInfo.gid}`;
+    }
+    return osUserAndGroupId;
+}

package/src/utils/getPathInfo.js

@@ -0,0 +1,18 @@
+export default function getPathInfo(path, base) {
+    let basePath = base;
+
+    const output = {
+        relative: path,
+        absolute: path,
+    };
+    if (basePath) {
+        if (basePath.at(-1) !== '/') basePath += '/';
+
+        if (path.substring(0, basePath.length) === basePath) {
+            output.relative = path.substring(basePath.length);
+        } else {
+            output.absolute = basePath + path;
+        }
+    }
+    return output;
+}

package/assets/CMakeLists.txt

@@ -1,8 +0,0 @@
-cmake_minimum_required(VERSION 3.1)
-project(cppjs)
-
-file(GLOB SRC_FILES "${BASE_DIR}/native/**/*.cpp" "${BASE_DIR}/native/*.cpp" "${BASE_DIR}/src/native/**/*.cpp" "${BASE_DIR}/src/native/*.cpp" "${BRIDGE_DIR}/*.i.cpp")
-add_library(cppjs STATIC ${SRC_FILES})
-
-file(GLOB HEADERS "${BASE_DIR}/node_modules/cppjs-lib-*/include")
-include_directories("${HEADERS};${BASE_DIR}/native;${BASE_DIR}/src/native")

package/src/createBridge.js

@@ -1,28 +0,0 @@
-import glob from 'glob';
-import os from "os";
-import { execFileSync } from 'child_process';
-import pullDockerImage from './pullDockerImage.js';
-import { getBaseInfo, getPathInfo, getOsUserAndGroupId } from './utils.js';
-
-export default function createBridge(filePath, outputPath, basePath = process.cwd()) {
-    pullDockerImage();
-
-    const input = getPathInfo(filePath, basePath);
-    const output = getPathInfo(outputPath, basePath);
-    const projectPath = getPathInfo(process.cwd(), basePath);
-    const base = getBaseInfo(basePath);
-
-    const includePath = [
-        glob.sync("node_modules/cppjs-lib-*-web/include", { absolute: false }),
-        glob.sync("native", { absolute: false }),
-        glob.sync("src/native", { absolute: false }),
-    ].filter(path => !!path.toString()).map(path => `-I/live/${projectPath.relative}/${path}`);
-
-    const options = { cwd: outputPath, stdio : 'pipe' };
-    const args = [
-        "run", "--user", getOsUserAndGroupId(), "-v", `${base.withoutSlash}:/live`, "bugra9/cpp.js",
-        "swig", "-c++", '-emscripten', '-o', `/live/${output.relative}/${filePath.split('/').at(-1)}.cpp`, ...includePath, `/live/${input.relative}`
-    ];
-    execFileSync("docker", args, options);
-    return `${base.withSlash}${output.relative}/${filePath.split('/').at(-1)}.cpp`;
-}

package/src/createWasm.js

@@ -1,66 +0,0 @@
-import { execFileSync } from 'child_process';
-import * as url from 'node:url';
-import pullDockerImage from './pullDockerImage.js';
-import { getBaseInfo, getPathInfo, getOsUserAndGroupId } from './utils.js';
-
-const __filename = url.fileURLToPath(import.meta.url);
-const temp = __filename.split('/');
-temp.pop();
-temp.pop();
-const __dirname = temp.join('/');
-
-export default function createWasm(cMakeFilePath, outputPath, tempPath, options = {}, basePath = process.cwd()) {
-    pullDockerImage();
-    cmake(cMakeFilePath, tempPath, basePath);
-    make(cMakeFilePath, tempPath, basePath);
-    cc(tempPath, outputPath, options.cc, basePath);
-
-    return outputPath;
-}
-
-function cmake(cMakeFilePath, outputPath, basePath) {
-    const output = getPathInfo(outputPath, basePath);
-    const projectPath = getPathInfo(process.cwd(), basePath);
-    const base = getBaseInfo(basePath);
-
-    let cMakeParentPath = cMakeFilePath.split('/');
-    cMakeParentPath.pop();
-    cMakeParentPath = cMakeParentPath.join('/');
-    const args = [
-        "run", "--user", getOsUserAndGroupId(), "-v", `${base.withoutSlash}:/live`, "-v", `${cMakeParentPath}:/cmake`, "--workdir", `/live/${output.relative}`, "bugra9/cpp.js",
-        "emcmake", "cmake", "/cmake", `-DBASE_DIR=/live/${projectPath.relative}`,
-        `-DCMAKE_INSTALL_PREFIX=/live/${output.relative}`, `-DBRIDGE_DIR=/live/${output.relative}`,
-    ];
-    const options = { cwd: outputPath, stdio : 'pipe' };
-    execFileSync("docker", args, options);
-    return outputPath;
-}
-
-function make(cMakeFilePath, outputPath, basePath) {
-    const output = getPathInfo(outputPath, basePath);
-    const base = getBaseInfo(basePath);
-
-    let cMakeParentPath = cMakeFilePath.split('/');
-    cMakeParentPath.pop();
-    cMakeParentPath = cMakeParentPath.join('/');
-    const args = [
-        "run", "--user", getOsUserAndGroupId(), "-v", `${base.withoutSlash}:/live`, "-v", `${cMakeParentPath}:/cmake`, "--workdir", `/live/${output.relative}`, "bugra9/cpp.js",
-        "emmake", "make"
-    ];
-    const options = { cwd: outputPath, stdio : 'pipe' };
-    execFileSync("docker", args, options);
-    return outputPath;
-}
-
-function cc(tempPath, outputPath, flags = [], basePath) {
-    const input = getPathInfo(tempPath, basePath);
-    const output = getPathInfo(outputPath, basePath);
-    const base = getBaseInfo(basePath);
-    const args = [
-        "run", "--user", getOsUserAndGroupId(), "-v", `${base.withoutSlash}:/live`, "-v", `${__dirname}:/cli`, "bugra9/cpp.js",
-        "emcc", "-lembind", "-Wl,--whole-archive", `/live/${input.relative}/libcppjs.a`, ...flags, "-s", "WASM=1", "-s", "MODULARIZE=1", '-o', `/live/${output.relative}/cpp.js`, '--extern-post-js', '/cli/src/extern-post.js'
-    ];
-    const options = { cwd: tempPath, stdio : 'pipe' };
-    execFileSync("docker", args, options);
-    return outputPath;
-}

package/src/findCMakeListsFile.js

@@ -1,17 +0,0 @@
-import fs from 'fs';
-import glob from 'glob';
-import {dirname} from 'path';
-import * as url from 'node:url';
-
-export const __filename = url.fileURLToPath(import.meta.url);
-export const __dirname = dirname(dirname(__filename)+'..');
-
-export default function findCMakeListsFile() {
-    let temp = glob.sync("CMakeLists.txt", { absolute: true });
-    if (temp.length === 0) {
-        temp = glob.sync("*/CMakeLists.txt", { absolute: true, ignore: ['node_modules/*', 'dist/*', 'build/*'] });
-    }
-
-    if (temp.length > 0) return temp[0];
-    return __dirname + '/assets/CMakeLists.txt';
-}

package/src/utils.js

@@ -1,101 +0,0 @@
-import fs from 'fs';
-import p, {dirname} from 'path';
-import os, { tmpdir } from "os";
-import * as url from 'node:url';
-
-export const __filename = url.fileURLToPath(import.meta.url);
-export const __dirname = dirname(__filename);
-
-let config;
-export const mainPath = process.cwd();
-
-export function createTempDir(folder) {
-    let path = p.join(tmpdir(), "cppjs-app-cli");
-    if (folder) path = p.join(path, folder);
-
-    if (fs.existsSync(path)) fs.rmdirSync(path);
-    fs.mkdirSync(path, { recursive: true });
-
-    return path;
-}
-
-export function getFilesGivenDir(dir, options = {}) {
-    return new Promise((resolve, reject) => {
-        fs.readdir(dir, (err, files) => {
-            if (err) reject(err);
-
-            let filteredFiles = files;
-            if (options.ext && Array.isArray(options.ext) && options.ext.length > 0) {
-                const regex = new RegExp(`\.(${options.ext.join('|')})$`, 'g');
-                filteredFiles = filteredFiles.filter(file => regex.test(file));
-            }
-            if (options.filter) filteredFiles = filteredFiles.filter(options.filter);
-            resolve(filteredFiles);
-        });
-    });
-}
-
-export async function getConfig(projectPath) {
-    if (config) return config;
-    if (!projectPath) projectPath = mainPath;
-
-    config = {
-        projectPath,
-        modulesPath: projectPath,
-        modulesTempPath: createTempDir('modules'),
-        bridgesTempPath: createTempDir('bridges'),
-        output: `${projectPath}/dist`,
-    };
-
-    const configFilePath = `${projectPath}/.cppjs.config.js`;
-    if (fs.existsSync(configFilePath)) {
-        config = Object.assign({}, config, (await import(configFilePath)).default);
-    }
-
-    return config;
-}
-
-let osUserAndGroupId;
-export function getOsUserAndGroupId() {
-    const userInfo = os.userInfo();
-    if (!osUserAndGroupId) {
-        osUserAndGroupId = `${userInfo.uid}:${userInfo.gid}`;
-    }
-    return osUserAndGroupId;
-}
-
-export function getBaseInfo(base) {
-    let basePath = base;
-
-    const output = {
-        withSlash: '/',
-        withoutSlash: '/',
-    };
-    if (basePath && basePath !== '/') {
-        if (basePath.at(-1) !== '/') basePath += '/';
-
-        output.withSlash = basePath;
-        output.withoutSlash = basePath.substring(0, basePath.length - 1);
-    }
-    return output;
-}
-
-
-export function getPathInfo(path, base) {
-    let basePath = base;
-
-    const output = {
-        relative: path,
-        absolute: path,
-    };
-    if (basePath) {
-        if (basePath.at(-1) !== '/') basePath += '/';
-
-        if (path.substring(0, basePath.length) === basePath) {
-            output.relative = path.substring(basePath.length);
-        } else {
-            output.absolute = basePath + path;
-        }
-    }
-    return output;
-}