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

package/package.json

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

package/src/actions/createXCFramework.js

@@ -26,7 +26,7 @@ export default function createXCFramework(overrideConfig = null) {
     const relativeOutput = upath.relative(projectPath, output);
 
     const targetParams = overrideConfig?.targetParams || getTargetParams();
-    const buildTargets = getFilteredBuildTargets(targetParams, { platform: 'ios', runtime: 'mt', buildType: (targetParams.buildType && targetParams.buildType !== 'all') ? targetParams.buildType : 'release' });
+    const buildTargets = getFilteredBuildTargets(targetParams, { platform: 'ios', runtime: 'mt', buildType: (targetParams.buildType && targetParams.buildType.length > 0) ? targetParams.buildType[0] : 'release' });
 
     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.');

package/src/actions/getData.js

@@ -1,14 +1,26 @@
- 
- 
+import fs from 'node:fs';
 import state from '../state/index.js';
-import { getFilteredTargetSpec } from './target.js';
+import { getFilteredTargetSpec, getBuildTargets } from './target.js';
 
 function getRecursiveData(obj, config, dependency, field, target) {
     const entryArray = getFilteredTargetSpec(dependency?.targetSpecs, target).map(s => s[field]);
     const entries = Object.assign({}, ...entryArray);
     Object.entries(entries).forEach(([dKey, value]) => {
         if (field === 'data') {
-            const key = `${dependency.paths.project}/dist/prebuilt/${target.path}/${dKey}`;
+            let key;
+            if (fs.existsSync(`${dependency.paths.project}/dist/prebuilt/${target.path}`)) {
+                key = `${dependency.paths.project}/dist/prebuilt/${target.path}/${dKey}`;
+            } else {
+                const releaseTarget = getBuildTargets({
+                    platform: [target.platform], arch: [target.arch], runtime: [target.runtime],
+                    runtimeEnv: [target.runtimeEnv], buildType: ['release']
+                })?.[0];
+                if (releaseTarget) {
+                    key = `${dependency.paths.project}/dist/prebuilt/${releaseTarget.path}/${dKey}`;
+                } else {
+                    throw new Error('Data not found');
+                }
+            }
             obj[key] = value;
         } else {
             if (typeof value === 'object' && Array.isArray(value)) {

package/src/actions/getDependLibs.js

@@ -8,7 +8,7 @@ export default function getDependLibs(target) {
     ];
     state.config.dependencyParameters.getCmakeDepends(target).forEach((d) => {
         if (d.export.libName) {
-            const ignoreLibNames = getFilteredTargetSpec(d?.targetSpecs).map(s => s.ignoreLibName).flat();
+            const ignoreLibNames = getFilteredTargetSpec(d?.targetSpecs, target).map(s => s.ignoreLibName).flat();
             d.export.libName.forEach((fileName) => {
                 if (ignoreLibNames?.includes(fileName)) return;
                 let libPaths = findFiles(`${d.paths.output}/prebuilt/${target.path}/lib/lib${fileName}.a`, { cwd: d.paths.project });

package/src/actions/target.js

@@ -1,33 +1,39 @@
 import state from '../state/index.js';
 
+const platforms = [...new Set(state.targets.map(target => target.platform).filter(t => t))];
+const archs = [...new Set(state.targets.map(target => target.arch).filter(t => t))];
+const runtimes = [...new Set(state.targets.map(target => target.runtime).filter(t => t))];
+const buildTypes = [...new Set(state.targets.map(target => target.buildType).filter(t => t))];
+const runtimeEnvs = [...new Set(state.targets.map(target => target.runtimeEnv).filter(t => t))];
+
 export function getTargetParams(givenTargetParams = {}, noParamCheck = false) {
     const { platform, arch, runtime, buildType, runtimeEnv } = givenTargetParams;
     if (!noParamCheck && (
-        (state.config.target.platform && platform && platform !== 'all' && state.config.target.platform !== platform)
-        || (state.config.target.arch && arch && arch !== 'all' && state.config.target.arch !== arch)
-        || (state.config.target.runtime && runtime && runtime !== 'all' && state.config.target.runtime !== runtime)
-        || (state.config.target.buildType && buildType && buildType !== 'all' && state.config.target.buildType !== buildType)
-        || (state.config.target.runtimeEnv && runtimeEnv && runtimeEnv !== 'all' && state.config.target.runtimeEnv !== runtimeEnv)
+        (state.config.target.platform && platform && !platform.includes(state.config.target.platform))
+        || (state.config.target.arch && arch && !arch.includes(state.config.target.arch))
+        || (state.config.target.runtime && runtime && !runtime.includes(state.config.target.runtime))
+        || (state.config.target.buildType && buildType && !buildType.includes(state.config.target.buildType))
+        || (state.config.target.runtimeEnv && runtimeEnv && !runtimeEnv.includes(state.config.target.runtimeEnv))
     )) {
         throw new Error('Invalid target parameters');
     }
     return {
-        platform: state.config.target.platform || platform || 'all',
-        arch: state.config.target.arch || arch || 'all',
-        runtime: state.config.target.runtime || runtime || 'all',
-        buildType: state.config.target.buildType || buildType || 'all',
-        runtimeEnv: state.config.target.runtimeEnv || runtimeEnv || 'all',
+        platform: state.config.target.platform ? [state.config.target.platform] : platform || platforms,
+        arch: state.config.target.arch ? [state.config.target.arch] : arch || archs,
+        runtime: state.config.target.runtime ? [state.config.target.runtime] : runtime || runtimes,
+        buildType: state.config.target.buildType ? [state.config.target.buildType] : buildType || buildTypes,
+        runtimeEnv: state.config.target.runtimeEnv ? [state.config.target.runtimeEnv] : runtimeEnv || runtimeEnvs,
     };
 }
 
 export function getBuildTargets(targetParams) {
     const { platform, arch, runtime, buildType, runtimeEnv } = targetParams;
     return state.targets.filter(t => (
-        (platform === 'all' || t.platform === platform)
-        && (arch === 'all' || t.arch === arch)
-        && (runtime === 'all' || t.runtime === runtime)
-        && (buildType === 'all' || t.buildType === buildType)
-        && (runtimeEnv === 'all' || t.runtimeEnv === runtimeEnv)
+        (!t.platform || platform.includes(t.platform))
+        && (!t.arch || arch.includes(t.arch))
+        && (!t.runtime || runtime.includes(t.runtime))
+        && (!t.buildType || buildType.includes(t.buildType))
+        && (!t.runtimeEnv || runtimeEnv.includes(t.runtimeEnv))
     ));
 }
 

package/src/bin.js

@@ -22,6 +22,12 @@ import findFiles from './utils/findFiles.js';
 
 const packageJSON = JSON.parse(fs.readFileSync(new URL('../package.json', import.meta.url)));
 
+const platforms = [...new Set(state.targets.map(target => target.platform).filter(t => t))];
+const archs = [...new Set(state.targets.map(target => target.arch).filter(t => t))];
+const runtimes = [...new Set(state.targets.map(target => target.runtime).filter(t => t))];
+const buildTypes = [...new Set(state.targets.map(target => target.buildType).filter(t => t))];
+const runtimeEnvs = [...new Set(state.targets.map(target => target.runtimeEnv).filter(t => t))];
+
 const program = new Command();
 
 program
@@ -32,11 +38,11 @@ program
 
 const commandBuild = program.command('build')
     .description('compile the project that was set up using Cpp.js')
-    .addOption(new Option('-p, --platform <platform>', 'target platform').default('all').choices(['all', 'wasm', 'android', 'ios']))
-    .addOption(new Option('-a, --arch <arch>', 'target architecture').default('all').choices(['all', 'wasm32', 'wasm64', 'x86_64', 'arm64-v8a', 'iphoneos', 'iphonesimulator']))
-    .addOption(new Option('-r, --runtime <runtime>', 'target runtime').default('all').choices(['all', 'st', 'mt']))
-    .addOption(new Option('-b, --build-type <buildType>', 'target build type').default('release').choices(['all', 'release', 'debug']))
-    .addOption(new Option('-re, --runtime-env <runtimeEnv>', 'target runtime environment').default('all').choices(['all', 'browser', 'node']));
+    .addOption(new Option('-p, --platform <platform>', 'target platform').argParser(createListParser(platforms)))
+    .addOption(new Option('-a, --arch <arch>', 'target architecture').argParser(createListParser(archs)))
+    .addOption(new Option('-r, --runtime <runtime>', 'target runtime').argParser(createListParser(runtimes)))
+    .addOption(new Option('-b, --build-type <buildType>', 'target build type').argParser(createListParser(buildTypes)))
+    .addOption(new Option('-re, --runtime-env <runtimeEnv>', 'target runtime environment').argParser(createListParser(runtimeEnvs)));
 
 const commandDocker = program.command('docker')
     .description('manage docker');
@@ -60,9 +66,20 @@ program.parse(process.argv);
 switch (program.args[0]) {
     case 'build': {
         const targetParams = commandBuild.opts();
-        if (targetParams.platform === 'wasm' && targetParams.arch === 'all') {
-            targetParams.arch = 'wasm32';
+
+        if (!targetParams.arch) {
+            targetParams.arch = archs.filter(item => item !== 'wasm64');
+        }
+        if (!targetParams.buildType) {
+            targetParams.buildType = ['release'];
         }
+
+        targetParams.platform = targetParams.platform || platforms;
+        targetParams.arch = targetParams.arch || archs;
+        targetParams.runtime = targetParams.runtime || runtimes;
+        targetParams.buildType = targetParams.buildType || buildTypes;
+        targetParams.runtimeEnv = targetParams.runtimeEnv || runtimeEnvs;
+
         if (state.config.build.withBuildConfig) {
             buildExternal(targetParams);
         } else {
@@ -320,7 +337,7 @@ function buildLib(targetParams) {
 
     createXCFramework();
 
-    const iosTargets = getBuildTargets({ platform: 'ios', arch: 'iphoneos', runtime: 'mt', buildType: 'release' });
+    const iosTargets = getBuildTargets({ platform: ['ios'], arch: ['iphoneos'], runtime: ['mt'], buildType: ['release'] });
     const podSpecs = findFiles('*.podspec', { cwd: state.config.paths.project });
     if (podSpecs.length === 0 && targets.length > 0) {
         const iosTarget = iosTargets[0];
@@ -390,3 +407,15 @@ async function createWasmJs(targetParams) {
         }
     }
 }
+
+function createListParser(validList) {
+    return (value, previous) => {
+        const items = value.split(',').map(item => item.trim());
+        for (const item of items) {
+            if (!validList.includes(item)) {
+                throw new Error(`Invalid value: "${item}". Allowed values: ${validList.join(', ')}`);
+            }
+        }
+        return previous ? previous.concat(items) : items;
+    };
+}