cpp.js 1.0.0-beta.1 → 1.0.0-beta.20

package/src/{functions → actions}/run.js

@@ -1,9 +1,8 @@
-import fs from 'fs';
-import { execFileSync } from 'child_process';
+import { execFileSync } from 'node:child_process';
+import fs from 'node:fs';
 import pullDockerImage, { getDockerImage } from '../utils/pullDockerImage.js';
 import getOsUserAndGroupId from '../utils/getOsUserAndGroupId.js';
-import getBaseInfo from '../utils/getBaseInfo.js';
-import getPathInfo from '../utils/getPathInfo.js';
+import state from '../state/index.js';
 
 const CROSSCOMPILER = 'aarch64-linux-android33';
 const ANDROID_NDK = '/opt/android-sdk/ndk/25.2.9519653';
@@ -72,16 +71,17 @@ function getParentPath(path) {
     return pathArray.join('/');
 }
 
-export default function run(compiler, program, params = [], dockerOptions = {}) {
-    const [basePlatform, ...arch] = (compiler.platform || 'unknown-unknown').split('-'); // Emscripten-x86_64, Android-arm64-v8a, iOS-iphoneos, iOS-iphonesimulator
+export default function run(program, params = [], platformPrefix = null, platform = null, dockerOptions = {}) {
+    const buildPath = platformPrefix ? `${state.config.paths.build}/${platformPrefix}/${platform}` : state.config.paths.build;
+    if (!fs.existsSync(buildPath)) {
+        fs.mkdirSync(buildPath, { recursive: true });
+    }
+
+    const [basePlatform, ...arch] = (platform || 'unknown-unknown').split('-'); // Emscripten-x86_64, Android-arm64-v8a, iOS-iphoneos, iOS-iphonesimulator
     if (basePlatform !== 'iOS' || program !== null) {
         pullDockerImage();
     }
 
-    const base = getBaseInfo(compiler.config.paths.base);
-    const temp = getPathInfo(compiler.config.paths.temp, compiler.config.paths.base);
-
-    const cMakeParentPath = getParentPath(compiler.config.paths.cmake);
     let dProgram = program;
     let dParams = params;
     let platformParams = [];
@@ -118,8 +118,8 @@ export default function run(compiler, program, params = [], dockerOptions = {})
                             '-DFRAMEWORK=TRUE',
                             '-DCMAKE_OSX_DEPLOYMENT_TARGET=13.0',
                             '-DCMAKE_SYSTEM_NAME=iOS',
-                            `-DMACOSX_FRAMEWORK_IDENTIFIER=org.js.cpp.${compiler.config.general.name}`,
-                            `-DCMAKE_XCODE_ATTRIBUTE_PRODUCT_BUNDLE_IDENTIFIER=org.js.cpp.${compiler.config.general.name}`,
+                            `-DMACOSX_FRAMEWORK_IDENTIFIER=org.js.cpp.${state.config.general.name}`,
+                            `-DCMAKE_XCODE_ATTRIBUTE_PRODUCT_BUNDLE_IDENTIFIER=org.js.cpp.${state.config.general.name}`,
                             `-DCMAKE_OSX_SYSROOT='${arch[0] === 'iphoneos' ? iosSdkPath : iosSimSdkPath}'`,
                             `-DCMAKE_OSX_ARCHITECTURES=${arch[0] === 'iphoneos' ? 'arm64;arm64e' : 'arm64;arm64e;x86_64'}`,
                             `-DCMAKE_C_FLAGS=${arch[0] === 'iphoneos' ? '-fembed-bitcode' : '-fembed-bitcode-marker'}`,
@@ -134,7 +134,7 @@ export default function run(compiler, program, params = [], dockerOptions = {})
                     if (dParams[0] !== '--build' && dParams[0] !== '--install') {
                         dParams = [
                             ...dParams,
-                            `-DCMAKE_TOOLCHAIN_FILE='${compiler.config.paths.cli}/assets/ios.toolchain.cmake'`,
+                            `-DCMAKE_TOOLCHAIN_FILE='${state.config.paths.cli}/assets/ios.toolchain.cmake'`,
                             `-DPLATFORM=${arch[0] === 'iphoneos' ? 'OS64' : 'SIMULATORARM64'}`,
                             `-DARCHS=${arch[0] === 'iphoneos' ? 'arm64;arm64e' : 'arm64;arm64e;x86_64'}`,
                             '-DENABLE_BITCODE=TRUE',
@@ -142,8 +142,8 @@ export default function run(compiler, program, params = [], dockerOptions = {})
                             '-DFRAMEWORK=TRUE',
                             '-DCMAKE_OSX_DEPLOYMENT_TARGET=13.0',
                             '-DCMAKE_SYSTEM_NAME=iOS',
-                            `-DMACOSX_FRAMEWORK_IDENTIFIER=org.js.cpp.${compiler.config.general.name}`,
-                            `-DCMAKE_XCODE_ATTRIBUTE_PRODUCT_BUNDLE_IDENTIFIER=org.js.cpp.${compiler.config.general.name}`,
+                            `-DMACOSX_FRAMEWORK_IDENTIFIER=org.js.cpp.${state.config.general.name}`,
+                            `-DCMAKE_XCODE_ATTRIBUTE_PRODUCT_BUNDLE_IDENTIFIER=org.js.cpp.${state.config.general.name}`,
                             `-DCMAKE_OSX_SYSROOT='${arch[0] === 'iphoneos' ? iosSdkPath : iosSimSdkPath}'`,
                             `-DCMAKE_OSX_ARCHITECTURES=${arch[0] === 'iphoneos' ? 'arm64;arm64e' : 'arm64;arm64e;x86_64'}`,
                             `-DCMAKE_C_FLAGS=${arch[0] === 'iphoneos' ? '-fembed-bitcode' : '-fembed-bitcode-marker'}`,
@@ -189,32 +189,54 @@ export default function run(compiler, program, params = [], dockerOptions = {})
         env.PATH = `/opt/homebrew/bin:${env.PATH}`;
 
         const options = {
-            cwd: dockerOptions.workdir || `/tmp/cppjs/live/${temp.relative}`,
+            cwd: dockerOptions.workdir || buildPath,
             stdio: dockerOptions.console ? 'inherit' : 'pipe',
             env,
         };
 
-        if (!fs.existsSync('/tmp/cppjs')) fs.mkdirSync('/tmp/cppjs');
-        if (fs.existsSync('/tmp/cppjs/live')) fs.unlinkSync('/tmp/cppjs/live');
-        fs.symlinkSync(base.withoutSlash, '/tmp/cppjs/live');
-        if (!fs.existsSync('/tmp/cppjs/cli')) fs.symlinkSync(compiler.config.paths.cli, '/tmp/cppjs/cli');
-        if (!fs.existsSync('/tmp/cppjs/cmake')) fs.symlinkSync(cMakeParentPath, '/tmp/cppjs/cmake');
-
         execFileSync(dProgram, dParams, options);
+    } else if (false) {
+        const options = { cwd: buildPath, stdio: dockerOptions.console ? 'inherit' : 'pipe' };
+        const args = [
+            'exec',
+            '--user', getOsUserAndGroupId(),
+            '--workdir', dockerOptions.workdir || replaceBasePathForDocker(buildPath),
+            'cppjs-builder',
+            dProgram,
+            ...replaceBasePathForDocker(dParams),
+        ];
+        execFileSync('docker', args, options);
     } else {
-        const options = { cwd: temp.absolute, stdio: dockerOptions.console ? 'inherit' : 'pipe' };
+        const options = { cwd: buildPath, stdio: dockerOptions.console ? 'inherit' : 'pipe' };
         const args = [
             'run',
+            '--rm',
             '--user', getOsUserAndGroupId(),
-            '-v', `${base.withoutSlash}:/tmp/cppjs/live`,
-            '-v', `${compiler.config.paths.cli}:/tmp/cppjs/cli`,
-            '-v', `${cMakeParentPath}:/tmp/cppjs/cmake`,
-            '--workdir', dockerOptions.workdir || `/tmp/cppjs/live/${temp.relative}`,
-            ...platformParams,
-            ...(dockerOptions.params || []),
+            '-v', `${state.config.paths.base}:/tmp/cppjs/live`,
+            '--workdir', dockerOptions.workdir || replaceBasePathForDocker(buildPath),
+            ...replaceBasePathForDocker(platformParams),
+            ...replaceBasePathForDocker(dockerOptions.params || []),
+            // '-e', replaceBasePathForDocker(`CCACHE_DIR=${state.config.paths.build}/ccache`),
             getDockerImage(),
-            dProgram, ...dParams,
+            dProgram,
+            ...replaceBasePathForDocker(dParams),
         ];
         execFileSync('docker', args, options);
     }
 }
+
+function replaceBasePathForDocker(data) {
+    if (typeof data === 'string' || data instanceof String) {
+        return data.replaceAll(state.config.paths.base, '/tmp/cppjs/live');
+    }
+    if (Array.isArray(data)) {
+        return data.map((d) => replaceBasePathForDocker(d));
+    }
+    if (typeof value === 'object' && data !== null) {
+        const newData = {};
+        Object.entries(data).forEach(([key, value]) => {
+            newData[key] = replaceBasePathForDocker(value);
+        });
+    }
+    return data;
+}

package/src/assets/CMakeLists.txt

@@ -29,7 +29,9 @@ if (BUILD_BRIDGE)
     file(GLOB BRIDGE_SRC_FILES "${BRIDGE_DIR}/*.i.cpp")
 endif(BUILD_BRIDGE)
 
-set(SRC_FILES "${BUILD_SRC_FILES}" "${BRIDGE_SRC_FILES}")
+file(GLOB_RECURSE EXTERNAL_SRC_FILES ${EXTERNAL_NATIVE_GLOB})
+
+set(SRC_FILES "${BUILD_SRC_FILES}" "${BRIDGE_SRC_FILES}" "${EXTERNAL_SRC_FILES}")
 add_library("${PROJECT_NAME}" "${BUILD_TYPE}" ${SRC_FILES})
 
 set(EXTRA_LINK_LIBRARIES "")
@@ -44,15 +46,17 @@ endif()
 file(GLOB_RECURSE HEADER_FILES ${HEADER_GLOB})
 target_include_directories("${PROJECT_NAME}" PUBLIC "${HEADER_DIR}")
 
+install(TARGETS "${PROJECT_NAME}" DESTINATION "lib")
+if(NOT "${HEADER_FILES}" STREQUAL "")
+    target_sources("${PROJECT_NAME}"
+        PUBLIC FILE_SET HEADERS
+        BASE_DIRS "${HEADER_DIR}"
+        FILES "${HEADER_FILES}")
+    install(TARGETS "${PROJECT_NAME}" FILE_SET HEADERS DESTINATION "include")
+endif()
+
 if (BUILD_SOURCE)
-    install(TARGETS "${PROJECT_NAME}" DESTINATION "lib")
-    if(NOT "${HEADER_FILES}" STREQUAL "")
-        target_sources("${PROJECT_NAME}"
-            PUBLIC FILE_SET HEADERS
-            BASE_DIRS "${HEADER_DIR}"
-            FILES "${HEADER_FILES}")
-        install(TARGETS "${PROJECT_NAME}" FILE_SET HEADERS DESTINATION "include")
-    endif()
+
 endif(BUILD_SOURCE)
 unset(BUILD_SOURCE CACHE)
 

package/src/assets/ios.toolchain.cmake

@@ -168,7 +168,7 @@ list(APPEND _supported_platforms
         "TVOS" "TVOSCOMBINED" "SIMULATOR_TVOS" "SIMULATORARM64_TVOS"
         "WATCHOS" "WATCHOSCOMBINED" "SIMULATOR_WATCHOS" "SIMULATORARM64_WATCHOS"
         "MAC" "MAC_ARM64" "MAC_UNIVERSAL"
-        "VISIONOS" "SIMULATOR_VISIONOS" "VISIONOSCOMBINED" 
+        "VISIONOS" "SIMULATOR_VISIONOS" "VISIONOSCOMBINED"
         "MAC_CATALYST" "MAC_CATALYST_ARM64" "MAC_CATALYST_UNIVERSAL")
 
 # Cache what generator is used
@@ -316,7 +316,7 @@ if(PLATFORM_INT STREQUAL "OS")
     set(ARCHS armv7 armv7s arm64)
     set(APPLE_TARGET_TRIPLE_INT arm-apple-ios${DEPLOYMENT_TARGET})
   else()
-    set(APPLE_TARGET_TRIPLE_INT ${ARCHS_SPLIT}-apple-ios${DEPLOYMENT_TARGET})  
+    set(APPLE_TARGET_TRIPLE_INT ${ARCHS_SPLIT}-apple-ios${DEPLOYMENT_TARGET})
   endif()
 elseif(PLATFORM_INT STREQUAL "OS64")
   set(SDK_NAME iphoneos)
@@ -1049,7 +1049,7 @@ set(CMAKE_TRY_COMPILE_PLATFORM_VARIABLES
 )
 
 if(NAMED_LANGUAGE_SUPPORT_INT)
-  list(APPEND CMAKE_TRY_COMPILE_PLATFORM_VARIABLES 
+  list(APPEND CMAKE_TRY_COMPILE_PLATFORM_VARIABLES
         CMAKE_OBJC_FLAGS
         CMAKE_OBJC_DEBUG
         CMAKE_OBJC_MINSIZEREL
@@ -1087,7 +1087,7 @@ IF(NOT DEFINED CMAKE_FIND_FRAMEWORK)
 ENDIF(NOT DEFINED CMAKE_FIND_FRAMEWORK)
 
 # Set up the default search directories for frameworks.
-if(PLATFORM_INT MATCHES "^MAC_CATALYST") 
+if(PLATFORM_INT MATCHES "^MAC_CATALYST")
   set(CMAKE_FRAMEWORK_PATH
           ${CMAKE_DEVELOPER_ROOT}/Library/PrivateFrameworks
           ${CMAKE_OSX_SYSROOT_INT}/System/Library/Frameworks

package/src/bin.js

@@ -1,43 +1,43 @@
 #!/usr/bin/env node
 
-import { Command, Argument } from 'commander';
+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 upath from 'upath';
 
-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';
 
 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.')
+    .name('cppjs')
+    .description('Compile C++ files to WebAssembly and native platforms.')
     .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 (all)', 'all', ['all', 'wasm', 'android', 'ios'])
-    .option('-o, --output <string>', 'Output path');
+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', 'WebAssembly', 'Android', 'iOS']));
 
 const commandRun = program.command('run')
-    .description('Run docker application');
+    .description('run docker application');
 
 const commandPostInstall = program.command('postinstall')
-    .description('npm postinstall');
+    .description('prepare the required packages for Cpp.js after installation');
 
 program.parse(process.argv);
 
 switch (program.args[0]) {
-    case 'generate': {
-        const type = commandGenerate.args[0];
-        const { output, platform, base } = commandGenerate.opts();
-        generate(type, platform, output, base);
+    case 'build': {
+        const { platform } = commandBuild.opts();
+        build(platform);
         break;
     }
     case 'run': {
@@ -55,20 +55,27 @@ switch (program.args[0]) {
 
 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`)) {
+    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`)
+        )
+    ) {
         return;
     }
 
-    const cppjs = new CppjsCompiler();
-    const name = cppjs?.config?.general?.name;
-    let dist = cppjs?.config?.paths?.output;
-    dist = dist ? getPathInfo(dist, projectPath).relative : null;
+    const name = state?.config?.general?.name;
+    let dist = state?.config?.paths?.output;
+    dist = dist ? upath.relative(projectPath, dist) : null;
 
     if (!name || !dist) {
         return;
     }
 
-    cppjs?.config?.export?.libName?.forEach((fileName) => {
+    state?.config?.export?.libName?.forEach((fileName) => {
         if (fs.existsSync(`${projectPath}/${fileName}.xcframework`) || !fs.existsSync(`${dist}/prebuilt/${fileName}.xcframework`)) {
             return;
         }
@@ -77,88 +84,53 @@ function postInstall() {
 }
 
 function run(programName, params) {
-    const compiler = new CppjsCompiler();
-    compiler.run(programName, params);
+    runCppjsApp(programName, params, null, null, { console: true });
 }
 
-function generate(type, platform) {
-    const compiler2 = new CppjsCompiler();
-    if (type === 'lib') {
-        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 (platform === 'all' || platform === 'wasm') {
-            if (!fs.existsSync(`${compiler2.config.paths.output}/prebuilt/Emscripten-x86_64`)) {
-                generateWasmLib();
-                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}`);
-                });
-            }
-        }
+async function build(platform) {
+    state.platforms[platform].forEach((p) => {
+        createLib(p, 'Source', { isProd: true, buildSource: 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();
-                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}`);
-                });
-            }
-        });
-        if (platform === 'all' || platform === 'ios') {
-            compiler2.finishBuild();
-        }
-    }
+    fs.cpSync(`${state.config.paths.build}/Source-Release/prebuilt`, `${state.config.paths.output}/prebuilt`, { recursive: true });
 
-    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);
-}
+    createXCFramework();
 
-async function generateWasmLib() {
     let headers = [];
-
-    const compiler = new CppjsCompiler();
-    compiler.config.paths.header.forEach((headerPath) => {
+    state.config.paths.header.forEach((headerPath) => {
         headers.push(glob.sync('**/*.h', { absolute: true, 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: 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 });
+    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);
 }

package/src/index.js

@@ -1,63 +1,10 @@
-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';

package/src/state/calculateDependencyParameters.js

@@ -0,0 +1,64 @@
+export default function calculateDependencyParameters(config) {
+    const sourceFilter = (d) => d === config || d.export.type === 'source';
+    let headerPathWithDepends = [];
+    setPath(headerPathWithDepends, config, 'header', sourceFilter);
+    headerPathWithDepends = [...new Set(headerPathWithDepends)].join(';');
+
+    const headerGlob = [];
+    headerPathWithDepends.split(';').forEach((h) => {
+        config.ext.header.forEach((ext) => {
+            headerGlob.push(`${h}/*.${ext}`);
+        });
+    });
+
+    let nativePathWithDepends = [];
+    setPath(nativePathWithDepends, config, 'native', sourceFilter);
+    nativePathWithDepends = [...new Set(nativePathWithDepends)].join(';');
+
+    const nativeGlob = [];
+    nativePathWithDepends.split(';').forEach((h) => {
+        config.ext.source.forEach((ext) => {
+            nativeGlob.push(`${h}/*.${ext}`);
+        });
+    });
+
+    const cmakeFilter = (d) => d !== config && d.export.type === 'cmake' && d.paths.cmake !== config.paths.cliCMakeListsTxt;
+    let cmakeDepends = [];
+    setPath(cmakeDepends, config, 'this', cmakeFilter);
+    cmakeDepends = [...new Set(cmakeDepends)];
+
+    const pathsOfCmakeDepends = [...new Set(cmakeDepends
+        .map((d) => getParentPath(d.paths.cmake)))].join(';');
+    const nameOfCmakeDepends = [...new Set(cmakeDepends.map((d) => d.general.name))].join(';');
+
+    return {
+        nativeGlob,
+        headerGlob,
+        headerPathWithDepends,
+        cmakeDepends,
+        pathsOfCmakeDepends,
+        nameOfCmakeDepends,
+    };
+}
+
+function setPath(arr, dependency, type, filter = () => {}) {
+    if (filter(dependency)) {
+        if (type === 'this') {
+            arr.push(dependency);
+        } else if (Array.isArray(dependency.paths[type])) {
+            arr.push(...dependency.paths[type]);
+        } else {
+            arr.push(dependency.paths[type]);
+        }
+    }
+
+    dependency.dependencies.forEach((dep) => {
+        setPath(arr, dep, type, filter);
+    });
+}
+
+function getParentPath(path) {
+    const pathArray = path.split('/');
+    pathArray.pop();
+    return pathArray.join('/');
+}

package/src/state/index.js

@@ -0,0 +1,44 @@
+import loadJson from '../utils/loadJson.js';
+import writeJson from '../utils/writeJson.js';
+import loadConfig from './loadConfig.js';
+
+const cacheDir = `${process.cwd()}/.cppjs`;
+
+const state = {
+    platforms: {
+        All: ['Emscripten-x86_64', 'Android-arm64-v8a', 'iOS-iphoneos', 'iOS-iphonesimulator'],
+        WebAssembly: ['Emscripten-x86_64'],
+        Android: ['Android-arm64-v8a'],
+        iOS: ['iOS-iphoneos', 'iOS-iphonesimulator'],
+    },
+    config: null,
+    cache: {
+        hashes: {},
+        interfaces: {},
+        bridges: {},
+    },
+};
+
+if (typeof module !== 'undefined' && module.exports) {
+    initProcessState();
+} else {
+    await initProcessState();
+}
+
+await initProcessState();
+
+async function initProcessState() {
+    state.cache = loadCacheState();
+    state.config = await loadConfig();
+}
+
+function loadCacheState() {
+    const stateFilePath = `${cacheDir}/cache.json`;
+    return loadJson(stateFilePath) || state.cache;
+}
+
+export function saveCache() {
+    writeJson(`${cacheDir}/cache.json`, state.cache);
+}
+
+export default state;