cpp.js 2.0.0-beta.2 → 2.0.0-beta.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cpp.js",
-  "version": "2.0.0-beta.2",
+  "version": "2.0.0-beta.4",
   "license": "MIT",
   "homepage": "https://cpp.js.org",
   "repository": "https://github.com/bugra9/cpp.js.git",

package/src/actions/buildJs.js

@@ -1,5 +1,5 @@
-/* eslint-disable no-await-in-loop */
-/* eslint-disable no-restricted-syntax */
+ 
+ 
 import { rollup } from 'rollup';
 import { nodeResolve } from '@rollup/plugin-node-resolve';
 import commonjs from '@rollup/plugin-commonjs';
@@ -21,7 +21,6 @@ const options = {
     browser: {
         plugins: [virtual(nodeLibs), nodeResolve(), commonjs({ transformMixedEsModules: true, ignoreTryCatch: 'remove' })],
         output: {
-            file: 'browser',
             format: 'umd',
             name: 'initCppJs',
         },
@@ -29,38 +28,33 @@ const options = {
     node: {
         plugins: [nodeResolve(), commonjs()],
         output: {
-            file: 'node',
             format: 'umd',
             name: 'initCppJs',
         },
     },
 };
 
-export default async function buildJS(input, type) {
-    const entryJS = `${state.config.paths.cli}/assets/${type}.js`;
-    const env = JSON.stringify(getData('env', 'Emscripten-x86_64', type));
+export default async function buildJS(target) {
+    const entryJS = `${state.config.paths.cli}/assets/${target.runtimeEnv}.js`;
+    const env = JSON.stringify(getData('env', target));
     const systemConfig = `export default {
         env: ${env},
         paths: {
-            wasm: '${state.config.general.name}.wasm',
-            data: '${state.config.general.name}.data.txt',
-            worker: '${state.config.general.name}.js',
+            wasm: '${target.wasmName}',
+            data: '${target.dataTxtName}',
+            worker: '${target.rawJsName}',
         }
     }`;
-    let file = input;
-    if (input.endsWith('.js')) {
-        file = input.substring(0, input.length - 3);
-    }
+
     // fs.renameSync(input, `${input}.raw.js`);
-    const option = options[type];
+    const option = options[target.runtimeEnv];
     option.plugins = [virtual({
         'cpp.js/systemConfig': systemConfig,
-        'cpp.js/module': `export { default } from '${input}';`,
+        'cpp.js/module': `export { default } from '${state.config.paths.build}/${target.rawJsName}';`,
     }), ...option.plugins];
     option.input = entryJS;
-    option.output.file = `${file}.${option.output.file}.js`;
+    option.output.file = `${state.config.paths.build}/${target.jsName}`;
     const bundle = await rollup(option);
     await bundle.write(option.output);
     // fs.rmSync(`${input}.raw.js`, { force: true });
 }
-//

package/src/actions/buildWasm.js

@@ -7,32 +7,46 @@ import buildJs from './buildJs.js';
 import triggerExtensions from './extensions.js';
 import state from '../state/index.js';
 
-export default async function buildWasm(type, isProd = false) {
+export default async function buildWasm(target) {
+    const isProd = target.buildType === 'release';
     const buildType = isProd ? 'Release' : 'Debug';
+
+    if (fs.existsSync(`${state.config.paths.build}/${target.jsName}`) && fs.existsSync(`${state.config.paths.build}/${target.wasmName}`)) {
+        console.log(`${target.path} ${target.runtimeEnv || ''} wasm is already built`);
+        return;
+    }
+
     const libs = [
-        ...getDependLibs(),
-        `${state.config.paths.build}/Source-${buildType}/Emscripten-x86_64/lib${state.config.general.name}.a`,
-        `${state.config.paths.build}/Bridge-${buildType}/Emscripten-x86_64/lib${state.config.general.name}.a`,
+        ...getDependLibs(target),
+        `${state.config.paths.build}/Source-${buildType}/${target.path}/lib${state.config.general.name}.a`,
+        `${state.config.paths.build}/Bridge-${buildType}/${target.path}/lib${state.config.general.name}.a`,
     ];
 
-    const binary = getData('binary', 'Emscripten-x86_64');
+    const binary = getData('binary', target);
+    const emccFlags = binary?.emccFlags || [];
+
+    triggerExtensions('buildWasm', 'beforeBuild', [emccFlags]);
+
+    if (target.runtime === 'mt' && !emccFlags.includes('-pthread')) {
+        emccFlags.push('-pthread');
+        emccFlags.push('-sPTHREAD_POOL_SIZE=4');
+    }
+
+    if (target.platform === 'wasm') {
+        emccFlags.push('-msimd128');
+    }
 
-    if (type === 'browser') {
+    if (target.arch === 'wasm64') {
+        emccFlags.push('-sMEMORY64=1');
+    }
+
+    if (target.runtimeEnv === 'browser') {
         console.log('wasm compiling for browser...');
         const t0 = performance.now();
-        const emccFlags = [
-            ...(binary?.emccFlags || []),
-            ...(getData('binary', 'Emscripten-x86_64', 'browser')?.emccFlags || []),
-        ];
 
         triggerExtensions('buildWasm', 'beforeBuildBrowser', [emccFlags]);
 
-        if (state.config.build.usePthread && !emccFlags.includes('-pthread')) {
-            emccFlags.push('-pthread');
-            emccFlags.push('-sPTHREAD_POOL_SIZE=4');
-        }
-
-        const data = Object.entries(getData('data', 'Emscripten-x86_64', 'browser')).map(([key, value]) => ['--preload-file', `${key.replaceAll('@', '@@')}@${value}`]).flat();
+        const data = Object.entries(getData('data', target)).map(([key, value]) => ['--preload-file', `${key.replaceAll('@', '@@')}@/cppjs/${value}`]).flat();
         run('emcc', [
             '-lembind', '-Wl,--whole-archive',
             ...emccFlags,
@@ -45,16 +59,16 @@ export default async function buildWasm(type, isProd = false) {
             //            '-s', 'ALLOW_MEMORY_GROWTH=1',
             '-s', 'EXPORTED_RUNTIME_METHODS=["FS", "ENV"]',
             '-fwasm-exceptions',
-            '-o', `${state.config.paths.build}/${state.config.general.name}.js`,
+            '-o', `${state.config.paths.build}/${target.rawJsName}`,
             ...data,
-        ]);
+        ], null, target);
         const t1 = performance.now();
         console.log('wasm compiled for browser...', Math.round(t1 - t0));
         console.log('js compiling for browser...');
         replace({
             regex: 'var _scriptName = ',
             replacement: `var _scriptName = 'cpp.worker.js'; //`,
-            paths: [`${state.config.paths.build}/${state.config.general.name}.js`],
+            paths: [`${state.config.paths.build}/${target.rawJsName}`],
             recursive: false,
             silent: true,
         });
@@ -65,7 +79,7 @@ export default async function buildWasm(type, isProd = false) {
             recursive: false,
             silent: true,
         }); */
-        await buildJs(`${state.config.paths.build}/${state.config.general.name}.js`, 'browser');
+        await buildJs(target);
         // fs.rmSync(`${state.config.paths.build}/${state.config.general.name}.js`);
         // fs.copyFileSync(`${state.config.paths.build}/${state.config.general.name}.browser.js`, `${state.config.paths.build}/${state.config.general.name}.js`);
         // fs.renameSync(`${state.config.paths.build}/${state.config.general.name}.js`, `${state.config.paths.build}/${state.config.general.name}.worker.browser.js`);
@@ -73,20 +87,11 @@ export default async function buildWasm(type, isProd = false) {
         console.log('js compiled for browser...', Math.round(t2 - t1));
     }
 
-    if (type === 'node') {
+    if (target.runtimeEnv === 'node') {
         console.log('wasm compiling for node...');
-        const emccFlags = [
-            ...(binary?.emccFlags || []),
-            ...(getData('binary', 'Emscripten-x86_64', 'node')?.emccFlags || []),
-        ];
 
         triggerExtensions('buildWasm', 'beforeBuildNodeJS', [emccFlags]);
 
-        if (state.config.build.usePthread && !emccFlags.includes('-pthread')) {
-            emccFlags.push('-pthread');
-            emccFlags.push('-sPTHREAD_POOL_SIZE=4');
-        }
-
         run('emcc', [
             '-lembind', '-Wl,--whole-archive', '-lnodefs.js',
             ...emccFlags,
@@ -99,18 +104,18 @@ export default async function buildWasm(type, isProd = false) {
             '-s', 'NODERAWFS',
             '-s', 'EXPORTED_RUNTIME_METHODS=["FS", "ENV", "NODEFS"]',
             '-fwasm-exceptions',
-            '-o', `${state.config.paths.build}/${state.config.general.name}.js`,
-        ]);
+            '-o', `${state.config.paths.build}/${target.rawJsName}`,
+        ], null, target);
         console.log('wasm compiled for node...');
         console.log('js compiling for node...');
-        await buildJs(`${state.config.paths.build}/${state.config.general.name}.js`, 'node');
+        await buildJs(target);
         if (emccFlags.includes('FETCH')) {
-            fs.appendFileSync(`${state.config.paths.build}/${state.config.general.name}.node.js`, 'var XMLHttpRequest = require(\'xhr2\');\n');
+            fs.appendFileSync(`${state.config.paths.build}/${target.jsName}`, 'var XMLHttpRequest = require(\'xhr2\');\n');
         }
         // fs.renameSync(`${state.config.paths.build}/${state.config.general.name}.js`, `${state.config.paths.build}/${state.config.general.name}.worker.node.js`);
         console.log('js compiled for node...');
 
-        Object.entries(getData('data', 'Emscripten-x86_64', 'node')).forEach(([key, value]) => {
+        Object.entries(getData('data', target)).forEach(([key, value]) => {
             if (fs.existsSync(key)) {
                 const dAssetPath = `${state.config.paths.build}/data/${value}`;
                 if (!fs.existsSync(dAssetPath)) {
@@ -121,7 +126,7 @@ export default async function buildWasm(type, isProd = false) {
         });
     }
 
-    if (fs.existsSync(`${state.config.paths.build}/${state.config.general.name}.data`)) {
-        fs.renameSync(`${state.config.paths.build}/${state.config.general.name}.data`, `${state.config.paths.build}/${state.config.general.name}.data.txt`);
+    if (fs.existsSync(`${state.config.paths.build}/${target.dataName}`)) {
+        fs.renameSync(`${state.config.paths.build}/${target.dataName}`, `${state.config.paths.build}/${target.dataTxtName}`);
     }
 }

package/src/actions/createInterface.js

@@ -1,11 +1,11 @@
-/* eslint-disable prefer-destructuring */
+ 
 import fs from 'node:fs';
 import upath from 'upath';
 import state, { saveCache } from '../state/index.js';
 import { getFileHash } from '../utils/hash.js';
 import run from './run.js';
 
-export default function createBridgeFile(headerOrModuleFilePath) {
+export default function createBridgeFile(headerOrModuleFilePath, target = state.targets.find((t) => t.platform === 'wasm')) {
     const interfaceFilePath = upath.resolve(headerOrModuleFilePath);
     if (!fs.existsSync(`${state.config.paths.build}/interface`)) {
         fs.mkdirSync(`${state.config.paths.build}/interface`, { recursive: true });
@@ -13,11 +13,11 @@ export default function createBridgeFile(headerOrModuleFilePath) {
     if (!fs.existsSync(`${state.config.paths.build}/bridge`)) {
         fs.mkdirSync(`${state.config.paths.build}/bridge`, { recursive: true });
     }
-    const interfaceFile = createInterfaceFile(interfaceFilePath);
-    return createBridgeFileFromInterfaceFile(interfaceFile);
+    const interfaceFile = createInterfaceFile(interfaceFilePath, target);
+    return createBridgeFileFromInterfaceFile(interfaceFile, target);
 }
 
-function createInterfaceFile(headerOrModuleFilePath) {
+function createInterfaceFile(headerOrModuleFilePath, target) {
     if (!headerOrModuleFilePath) {
         return null;
     }
@@ -37,7 +37,7 @@ function createInterfaceFile(headerOrModuleFilePath) {
         return newPath;
     }
 
-    const headerPaths = (state.config.dependencyParameters?.pathsOfCmakeDepends?.split(';') || [])
+    const headerPaths = (state.config.dependencyParameters?.getCmakeDependsPathAndName(target).pathsOfCmakeDepends || [])
         .filter((d) => d.startsWith(state.config.paths.base));
 
     const temp2 = headerPaths
@@ -92,7 +92,7 @@ function createInterfaceFile(headerOrModuleFilePath) {
     return outputFilePath;
 }
 
-function createBridgeFileFromInterfaceFile(interfaceFilePath) {
+function createBridgeFileFromInterfaceFile(interfaceFilePath, target) {
     if (!interfaceFilePath) {
         return null;
     }
@@ -105,8 +105,8 @@ function createBridgeFileFromInterfaceFile(interfaceFilePath) {
     const allHeaders = state.config.dependencyParameters.headerPathWithDepends.split(';');
 
     let includePath = [
-        ...state.config.allDependencies.map((d) => `${d.paths.output}/prebuilt/Emscripten-x86_64/include`),
-        ...state.config.allDependencies.map((d) => `${d.paths.output}/prebuilt/Emscripten-x86_64/swig`),
+        ...state.config.allDependencies.map((d) => `${d.paths.output}/prebuilt/${target.path}/include`),
+        ...state.config.allDependencies.map((d) => `${d.paths.output}/prebuilt/${target.path}/swig`),
         ...state.config.paths.header,
         ...allHeaders,
     ].filter((path) => !!path.toString()).map((path) => `-I${path}`);
@@ -118,7 +118,7 @@ function createBridgeFileFromInterfaceFile(interfaceFilePath) {
         '-o', `${state.config.paths.build}/bridge/${interfaceFilePath.split('/').at(-1)}.cpp`,
         ...includePath,
         interfaceFilePath,
-    ]);
+    ], null, target);
 
     state.cache.bridges[interfaceFilePath] = `${state.config.paths.build}/bridge/${interfaceFilePath.split('/').at(-1)}.cpp`;
     state.cache.hashes[interfaceFilePath] = fileHash;

package/src/actions/createLib.js

@@ -8,33 +8,36 @@ import triggerExtensions from './extensions.js';
 import state from '../state/index.js';
 
 const cpuCount = os.cpus().length - 1;
-const sharedPlatforms = ['Android'];
+const sharedPlatforms = ['android'];
 
-export default function createLib(platform, fileType, options = {}) {
-    if (!platform || !options || typeof options !== 'object' || Array.isArray(options)) {
-        throw new Error('invalid platform or options');
+export default function createLib(target, fileType, options = {}) {
+    if (!target || !options || typeof options !== 'object' || Array.isArray(options)) {
+        throw new Error('invalid target or options');
     }
 
-    const basePlatform = platform.split('-', 1)[0];
-    if (basePlatform === 'iOS' && process.platform !== 'darwin') {
+    if (target.platform === 'ios' && process.platform !== 'darwin') {
         return;
     }
 
-    const buildType = options.isProd ? 'Release' : 'Debug';
+    const buildType = target.buildType === 'release' ? 'Release' : 'Debug';
     const platformPrefix = `${fileType ? `${fileType}-` : ''}${buildType}`;
-    const libdir = `${state.config.paths.build}/${platformPrefix}/prebuilt/${platform}`;
-    const buildPath = `${state.config.paths.build}/${platformPrefix}/${platform}`;
+    const libdir = `${state.config.paths.build}/${platformPrefix}/prebuilt/${target.path}`;
+    const buildPath = `${state.config.paths.build}/${platformPrefix}/${target.path}`;
+    if (fs.existsSync(`${libdir}/lib`)) {
+        console.log(`${target.path} is already built`);
+        return;
+    }
 
     const buildEnv = { params: [] };
     let buildParams;
-    const depPaths = state.config.allDependencyPaths[platform];
+    const depPaths = state.config.allDependencyPaths[target.path];
     if (state.config.build.withBuildConfig) {
-        const { getBuildParams, getExtraLibs, usePthread } = state.config.build;
+        const { getBuildParams, getExtraLibs } = state.config.build;
         buildEnv.console = true;
-        const ext = sharedPlatforms.includes(basePlatform) ? 'so' : 'a';
-        buildParams = getBuildParams ? getBuildParams(platform, depPaths, ext, buildPath) : [];
+        const ext = sharedPlatforms.includes(target.platform) ? 'so' : 'a';
+        buildParams = getBuildParams ? getBuildParams(target, depPaths, ext, buildPath) : [];
         if (state.config.build?.buildType !== 'configure') {
-            const cmakeBuildType = sharedPlatforms.includes(basePlatform) ? 'SHARED' : 'STATIC';
+            const cmakeBuildType = sharedPlatforms.includes(target.platform) ? 'SHARED' : 'STATIC';
             buildParams.push(`-DCMAKE_PREFIX_PATH=${libdir}`, `-DCMAKE_FIND_ROOT_PATH=${libdir}`, `-DBUILD_TYPE=${cmakeBuildType}`);
         }
 
@@ -42,50 +45,71 @@ export default function createLib(platform, fileType, options = {}) {
         const ldFlags = Object.values(depPaths).filter(d => d.libPath).map((d) => `-L${d.libPath}`);
         let dependLibs = '';
         if (state.config.build?.buildType === 'configure') {
-            dependLibs = Object.keys(depPaths).filter(d => d).map((d) => `-l${d}`).join(' ');
+            dependLibs = Object.keys(depPaths).filter(d => d && d !== 'cmake').map((d) => `-l${d}`).join(' ');
         }
 
-        const extraLibs = getExtraLibs ? getExtraLibs(platform) : [];
+        const extraLibs = getExtraLibs ? getExtraLibs(target) : [];
 
         triggerExtensions('createLib', 'setFlagWithBuildConfig', [buildEnv, cFlags, ldFlags]);
-
-        if (usePthread) {
+        if (target.runtime === 'mt') {
             cFlags.push('-pthread');
             ldFlags.push('-pthread');
         }
 
+        if (target.platform === 'wasm') {
+            cFlags.push('-msimd128');
+            ldFlags.push('-msimd128');
+        }
+
+        if (target.platform === 'wasm' && target.arch === 'wasm64') {
+            cFlags.push('-sMEMORY64=1');
+            ldFlags.push('-sMEMORY64=1');
+        }
+
         buildEnv.params.push('-e', `CFLAGS=${cFlags.join(' ')}`);
         buildEnv.params.push('-e', `CXXFLAGS=${cFlags.join(' ')}`);
         buildEnv.params.push('-e', `LDFLAGS=${ldFlags.join(' ')} ${extraLibs.join(' ')}`);
-        // buildEnv.params.push('-e', `LIBS=${dependLibs} ${extraLibs.join(' ')}`);
+        buildEnv.params.push('-e', `LIBS=${dependLibs} ${extraLibs.join(' ')}`);
 
         let configBuildEnv = state.config.build.env;
         if (configBuildEnv && typeof configBuildEnv === 'function') {
-            configBuildEnv = configBuildEnv(platform);
+            configBuildEnv = configBuildEnv(target);
         }
         configBuildEnv?.forEach((e) => {
             buildEnv.params.push('-e', e);
         });
     } else {
-        buildParams = getCmakeParameters(platform, options);
+        buildParams = getCmakeParameters(target, options);
 
         triggerExtensions('createLib', 'setFlagWithoutBuildConfig', [buildEnv]);
 
-        if (state.config.build.usePthread) {
+        if (target.runtime === 'mt') {
             buildEnv.params.push('-e', `CFLAGS=-pthread`);
             buildEnv.params.push('-e', `CXXFLAGS=-pthread`);
             buildEnv.params.push('-e', `LDFLAGS=-pthread`);
         }
+
+        if (target.platform === 'wasm') {
+            buildEnv.params.push('-e', `CFLAGS=-msimd128`);
+            buildEnv.params.push('-e', `CXXFLAGS=-msimd128`);
+            buildEnv.params.push('-e', `LDFLAGS=-msimd128`);
+        }
+
+        if (target.platform === 'wasm' && target.arch === 'wasm64') {
+            buildEnv.params.push('-e', `CFLAGS=-sMEMORY64=1`);
+            buildEnv.params.push('-e', `CXXFLAGS=-sMEMORY64=1`);
+            buildEnv.params.push('-e', `LDFLAGS=-sMEMORY64=1`);
+        }
     }
 
-    console.log(`${platform} is compiling...`);
+    console.log(`${target.path} ${target.runtimeEnv || ''} ${fileType} is compiling...`);
     const t0 = performance.now();
     const cmakeDir = state.config.build.withBuildConfig ? `${state.config.paths.build}/source` : state.config.paths.cmakeDir;
 
     if (state.config.build?.beforeRun) {
         const dataList = state.config.build?.beforeRun(cmakeDir);
         dataList.forEach((data) => {
-            run(data.program, data.parameters || [], platformPrefix, platform, buildEnv);
+            run(data.program, data.parameters || [], platformPrefix, target, buildEnv);
         });
     }
 
@@ -93,7 +117,7 @@ export default function createLib(platform, fileType, options = {}) {
         if (state.config.build?.buildType === 'configure') {
             fs.cpSync(cmakeDir, buildPath, { recursive: true });
             if (state.config.build?.sourceReplaceList) {
-                state.config.build.sourceReplaceList(platform, depPaths)?.forEach(({ regex, replacement, paths }) => {
+                state.config.build.sourceReplaceList(target, depPaths)?.forEach(({ regex, replacement, paths }) => {
                     replace({
                         regex, replacement, paths: paths.map((p) => `${buildPath}/${p}`), recursive: false, silent: true,
                     });
@@ -103,23 +127,23 @@ export default function createLib(platform, fileType, options = {}) {
                 './configure',
                 ...buildParams,
                 `--prefix=${libdir}`,
-            ], platformPrefix, platform, buildEnv);
+            ], platformPrefix, target, buildEnv);
         } else {
             run(null, [
-                basePlatform === 'iOS' && state.config.build?.useIOSCMake ? 'ios-cmake' : 'cmake', cmakeDir,
+                target.platform === 'ios' && state.config.build?.useIOSCMake ? 'ios-cmake' : 'cmake', cmakeDir,
                 `-DCMAKE_BUILD_TYPE=${buildType}`,
                 `-DCMAKE_INSTALL_PREFIX=${libdir}`,
                 ...buildParams,
-            ], platformPrefix, platform, buildEnv);
+            ], platformPrefix, target, buildEnv);
         }
     }
     const t1 = performance.now();
-    if (basePlatform === 'iOS' && state.config.build?.buildType !== 'configure') {
+    if (target.platform === 'ios' && state.config.build?.buildType !== 'configure') {
         const iOSCMakeBuilder = state.config.build?.useIOSCMake ? 'ios-cmake' : 'cmake';
-        run(null, [iOSCMakeBuilder, '--build', '.', '-j', cpuCount, '--config', buildType, '--target', 'install'], platformPrefix, platform, { console: buildEnv.console });
+        run(null, [iOSCMakeBuilder, '--build', '.', '-j', cpuCount, '--config', buildType, '--target', 'install'], platformPrefix, target, { console: buildEnv.console });
     } else {
-        run(null, ['make', `-j${cpuCount}`, 'install'], platformPrefix, platform, { console: buildEnv.console });
+        run(null, ['make', `-j${cpuCount}`, 'install'], platformPrefix, target, { console: buildEnv.console });
     }
     const t2 = performance.now();
-    console.log(`${platform} compiled`, platformPrefix, `full time: ${Math.round(t2 - t0)}ms`, `cmake: ${Math.round(t1 - t0)}ms`, `build: ${Math.round(t2 - t1)}ms`, `core: ${cpuCount}`);
+    console.log(`${target.path} ${target.runtimeEnv || ''} ${fileType} compiled`, platformPrefix, `full time: ${Math.round(t2 - t0)}ms`, `cmake: ${Math.round(t1 - t0)}ms`, `build: ${Math.round(t2 - t1)}ms`, `core: ${cpuCount}`);
 }

package/src/actions/createXCFramework.js

@@ -2,6 +2,7 @@ import fs from 'node:fs';
 import upath from 'upath';
 import { execFileSync } from 'node:child_process';
 import state from '../state/index.js';
+import { getTargetParams, getFilteredBuildTargets } from './target.js';
 
 const iOSDevPath = '/Applications/Xcode.app/Contents/Developer';
 const iosBinPath = `${iOSDevPath}/Toolchains/XcodeDefault.xctoolchain/usr/bin`;
@@ -9,6 +10,7 @@ const iosRanLibBin = `${iosBinPath}/ranlib`;
 
 export default function createXCFramework(overrideConfig = null) {
     if (process.platform !== 'darwin') {
+        console.log('XCFramework not created because platform is not darwin.');
         return;
     }
 
@@ -16,11 +18,6 @@ export default function createXCFramework(overrideConfig = null) {
     const projectPath = overrideConfig?.paths?.project || state.config.paths.project;
     const libName = overrideConfig?.export?.libName || state.config.export.libName;
 
-    if (
-        !fs.existsSync(`${output}/prebuilt/iOS-iphoneos/lib`)
-        || !fs.existsSync(`${output}/prebuilt/iOS-iphonesimulator/lib`)
-    ) return;
-
     const options = {
         cwd: projectPath,
         stdio: 'inherit',
@@ -28,23 +25,44 @@ export default function createXCFramework(overrideConfig = null) {
 
     const relativeOutput = upath.relative(projectPath, output);
 
-    libName.forEach((fileName) => {
-        if (!fs.existsSync(`${projectPath}/${fileName}.xcframework`)) {
-            execFileSync(iosRanLibBin, [`${relativeOutput}/prebuilt/iOS-iphoneos/lib/lib${fileName}.a`], options);
-            execFileSync(iosRanLibBin, [`${relativeOutput}/prebuilt/iOS-iphonesimulator/lib/lib${fileName}.a`], options);
-            const params = [
-                '-create-xcframework',
-                '-library', `${relativeOutput}/prebuilt/iOS-iphoneos/lib/lib${fileName}.a`,
-                '-headers', `${relativeOutput}/prebuilt/iOS-iphoneos/include`,
-                '-library', `${relativeOutput}/prebuilt/iOS-iphonesimulator/lib/lib${fileName}.a`,
-                '-headers', `${relativeOutput}/prebuilt/iOS-iphonesimulator/include`,
-                '-output', `${fileName}.xcframework`,
-            ];
-            execFileSync('xcodebuild', params, options);
-        }
+    const targetParams = overrideConfig?.targetParams || getTargetParams();
+    const buildTargets = getFilteredBuildTargets(targetParams, { platform: 'ios', runtime: 'mt', buildType: (targetParams.buildType && targetParams.buildType !== 'all') ? targetParams.buildType : 'release' });
 
-        if (!fs.existsSync(`${output}/prebuilt/${fileName}.xcframework.zip`)) {
-            execFileSync('zip', ['-y', '-r', `${relativeOutput}/prebuilt/${fileName}.xcframework.zip`, `${fileName}.xcframework`], options);
+    if (buildTargets.some(t => !fs.existsSync(`${output}/prebuilt/${t.path}/lib`))) {
+        console.log('XCFramework not created because some of the build targets are not built.');
+        return;
+    }
+
+    const targets = {};
+    buildTargets.forEach((target) => {
+        const p = `${target.platform}-${target.runtime}-${target.buildType}`;
+        if (!targets[p]) {
+            targets[p] = {};
         }
+        targets[p][target.arch] = target;
+    });
+
+    libName.forEach((fileName) => {
+        Object.values(targets).forEach((a) => {
+            const targets = Object.values(a);
+            // const targetName = `${fileName}-${targets[0].runtime}-${targets[0].buildType}.xcframework`;
+            const targetName = `${fileName}.xcframework`;
+            if (!fs.existsSync(`${projectPath}/${targetName}`)) {
+                console.log(`Creating XCFramework ${targetName}`);
+                const params = ['-create-xcframework'];
+                targets.forEach((target) => {
+                    execFileSync(iosRanLibBin, [`${relativeOutput}/prebuilt/${target.path}/lib/lib${fileName}.a`], options);
+                    params.push(
+                        '-library', `${relativeOutput}/prebuilt/${target.path}/lib/lib${fileName}.a`,
+                        '-headers', `${relativeOutput}/prebuilt/${target.path}/include`,
+                    );
+                });
+                params.push('-output', targetName);
+                execFileSync('xcodebuild', params, options);
+                console.log(`XCFramework ${targetName} created.`);
+            } else {
+                console.log(`XCFramework ${targetName} already exists.`);
+            }
+        });
     });
 }

package/src/actions/getCmakeParameters.js

@@ -2,7 +2,7 @@ import fs from 'node:fs';
 import state from '../state/index.js';
 import getData from './getData.js';
 
-export default function getCmakeParameters(platform, options = {}) {
+export default function getCmakeParameters(target, options = {}) {
     if (!options || typeof options !== 'object' || Array.isArray(options)) {
         throw new Error('invalid options');
     }
@@ -32,34 +32,28 @@ export default function getCmakeParameters(platform, options = {}) {
         ...(options.headerDirs || []),
     ];
 
-    const basePlatform = platform.split('-', 1)[0];
-    const sharedPlatforms = ['Android'];
-    const buildType = sharedPlatforms.includes(basePlatform) ? 'SHARED' : 'STATIC';
+    const sharedPlatforms = ['android'];
+    const buildType = sharedPlatforms.includes(target.platform) ? 'SHARED' : 'STATIC';
     const otherBuildType = buildType === 'STATIC' ? 'SHARED' : 'STATIC';
 
-    const cmakeCompileOptions = [...new Set(getData('cmake', platform)?.compileOptions || [])];
-
-    const pathsOfCmakeDepends = dependParams.pathsOfCmakeDepends.split(';');
-    const nameOfCmakeDepends = dependParams.nameOfCmakeDepends.split(';');
-    const pathsOfCmakeDependsFilteredByPlatform = [];
-    const nameOfCmakeDependsFilteredByPlatform = [];
-    pathsOfCmakeDepends.forEach((d, i) => {
-        if (fs.existsSync(`${d}/${platform}`) || (basePlatform === 'iOS' && fs.existsSync(`${d}/../../${nameOfCmakeDepends[i]}.xcframework`))) {
-            pathsOfCmakeDependsFilteredByPlatform.push(d);
-            nameOfCmakeDependsFilteredByPlatform.push(nameOfCmakeDepends[i]);
-        }
-    });
+    const cmakeCompileOptions = [...new Set(getData('cmake', target)?.compileOptions || [])];
 
     params.push(...[
         `-DPROJECT_NAME=${options.name || state.config.general.name}`,
+        // `-DPACKAGE_NAME_SUFFIX=${target.platform === 'ios' ? `-${target.runtime}-${target.buildType}` : ''}`,
+        `-DPROJECT_TARGET_PLATFORM=${target.platform}`,
+        `-DPROJECT_TARGET_ARCH=${target.arch}`,
+        `-DPROJECT_TARGET_RUNTIME=${target.runtime}`,
+        `-DPROJECT_TARGET_HOST=${target.platform}-${target.arch}-${target.runtime}-${target.buildType}`,
+        `-DPROJECT_TARGET_HOST_RELEASE=${target.platform}-${target.arch}-${target.runtime}-release`,
         `-DBASE_DIR=${state.config.paths.project}`,
         `-DEXTERNAL_NATIVE_GLOB=${externalNativeGlob.join(';')}`,
         `-DEXTERNAL_BRIDGE_GLOB=${externalBridgeGlob.join(';')}`,
         `-DNATIVE_GLOB=${nativeGlob.join(';')}`,
         `-DHEADER_GLOB=${headerGlob.join(';')}`,
         `-DHEADER_DIR=${headerDirs.join(';')}`,
-        `-DDEPENDS_CMAKE_PATHS=${pathsOfCmakeDependsFilteredByPlatform.join(';')}`,
-        `-DDEPENDS_CMAKE_NAMES=${nameOfCmakeDependsFilteredByPlatform.join(';')}`,
+        `-DDEPENDS_CMAKE_PATHS=${dependParams.getCmakeDependsPathAndName(target).pathsOfCmakeDepends.join(';')}`,
+        `-DDEPENDS_CMAKE_NAMES=${dependParams.getCmakeDependsPathAndName(target).nameOfCmakeDepends.join(';')}`,
         `-DBRIDGE_DIR=${state.config.paths.build}/bridge`,
         `-DBUILD_TYPE=${buildType}`,
         `-DBUILD_${otherBuildType}_LIBS=OFF`,