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

package/src/integration/getDependFilePath.js

@@ -1,7 +1,7 @@
 import fs from 'node:fs';
 import state from '../state/index.js';
 
-export default function getDependFilePath(source, platform) {
+export default function getDependFilePath(source, target) {
     const headerRegex = new RegExp(`\\.(${state.config.ext.header.join('|')})$`);
     const moduleRegex = new RegExp(`\\.(${state.config.ext.module.join('|')})$`);
 
@@ -13,11 +13,11 @@ export default function getDependFilePath(source, platform) {
 
         let path;
         if (headerRegex.test(source)) {
-            path = `${dependPackage.paths.output}/prebuilt/${platform}/include`;
+            path = `${dependPackage.paths.output}/prebuilt/${target.path}/include`;
         } else if (moduleRegex.test(source)) {
-            path = `${dependPackage.paths.output}/prebuilt/${platform}/swig`;
+            path = `${dependPackage.paths.output}/prebuilt/${target.path}/swig`;
         } else {
-            path = `${dependPackage.paths.output}/prebuilt/${platform}`;
+            path = `${dependPackage.paths.output}/prebuilt/${target.path}`;
         }
 
         if (fs.existsSync(`${path}/${configName}/${filePath}`)) {

package/src/state/calculateDependencyParameters.js

@@ -27,23 +27,32 @@ export default function calculateDependencyParameters(config) {
     setPath(cmakeDepends, config, 'this', cmakeFilter);
     cmakeDepends = [...new Set(cmakeDepends)];
 
-    const pathsOfCmakeDepends = [];
-    const nameOfCmakeDepends = [];
-    cmakeDepends.forEach((d) => {
-        const dependPath = getParentPath(d.paths.cmake);
-        if (!pathsOfCmakeDepends.includes(dependPath)) {
-            pathsOfCmakeDepends.push(dependPath);
-            nameOfCmakeDepends.push(d.general.name);
-        }
-    });
+    const getCmakeDepends = (target, variants = []) => {
+        return cmakeDepends.filter(d => d.functions.isEnabled(target, variants));
+    };
+
+    const getCmakeDependsPathAndName = (target, variants = []) => {
+        const pathsOfCmakeDepends = [];
+        const nameOfCmakeDepends = [];
+        getCmakeDepends(target, variants).forEach((d) => {
+            const dependPath = d.paths.cmakeDir;
+            if (!pathsOfCmakeDepends.includes(dependPath)) {
+                pathsOfCmakeDepends.push(dependPath);
+                nameOfCmakeDepends.push(d.general.name);
+            }
+        });
+        return {
+            pathsOfCmakeDepends: pathsOfCmakeDepends,
+            nameOfCmakeDepends: nameOfCmakeDepends,
+        };
+    }
 
     return {
         nativeGlob,
         headerGlob,
         headerPathWithDepends,
-        cmakeDepends,
-        pathsOfCmakeDepends: pathsOfCmakeDepends.join(';'),
-        nameOfCmakeDepends: nameOfCmakeDepends.join(';'),
+        getCmakeDepends,
+        getCmakeDependsPathAndName,
     };
 }
 
@@ -62,9 +71,3 @@ function setPath(arr, dependency, type, filter = () => { }) {
         setPath(arr, dep, type, filter);
     });
 }
-
-function getParentPath(path) {
-    const pathArray = path.split('/');
-    pathArray.pop();
-    return pathArray.join('/');
-}

package/src/state/index.js

@@ -5,12 +5,168 @@ import loadConfig from './loadConfig.js';
 const cacheDir = `${process.cwd()}/.cppjs`;
 
 const state = {
-    platforms: {
-        All: ['Emscripten-x86_64', 'Android-arm64-v8a', 'Android-x86_64', 'iOS-iphoneos', 'iOS-iphonesimulator'],
-        WebAssembly: ['Emscripten-x86_64'],
-        Android: ['Android-arm64-v8a', 'Android-x86_64'],
-        iOS: ['iOS-iphoneos', 'iOS-iphonesimulator'],
-    },
+    targets: [
+        {
+            platform: 'wasm',
+            arch: 'wasm32',
+            runtime: 'st',
+            buildType: 'release',
+            runtimeEnv: 'browser',
+        },
+        {
+            platform: 'wasm',
+            arch: 'wasm32',
+            runtime: 'st',
+            buildType: 'release',
+            runtimeEnv: 'node',
+        },
+        {
+            platform: 'wasm',
+            arch: 'wasm32',
+            runtime: 'st',
+            buildType: 'debug',
+            runtimeEnv: 'browser',
+        },
+        {
+            platform: 'wasm',
+            arch: 'wasm32',
+            runtime: 'st',
+            buildType: 'debug',
+            runtimeEnv: 'node',
+        },
+        {
+            platform: 'wasm',
+            arch: 'wasm32',
+            runtime: 'mt',
+            buildType: 'release',
+            runtimeEnv: 'browser',
+        },
+        {
+            platform: 'wasm',
+            arch: 'wasm32',
+            runtime: 'mt',
+            buildType: 'release',
+            runtimeEnv: 'node',
+        },
+        {
+            platform: 'wasm',
+            arch: 'wasm32',
+            runtime: 'mt',
+            buildType: 'debug',
+            runtimeEnv: 'browser',
+        },
+        {
+            platform: 'wasm',
+            arch: 'wasm32',
+            runtime: 'mt',
+            buildType: 'debug',
+            runtimeEnv: 'node',
+        },
+        {
+            platform: 'wasm',
+            arch: 'wasm64',
+            runtime: 'st',
+            buildType: 'release',
+            runtimeEnv: 'browser',
+        },
+        {
+            platform: 'wasm',
+            arch: 'wasm64',
+            runtime: 'st',
+            buildType: 'release',
+            runtimeEnv: 'node',
+        },
+        {
+            platform: 'wasm',
+            arch: 'wasm64',
+            runtime: 'st',
+            buildType: 'debug',
+            runtimeEnv: 'browser',
+        },
+        {
+            platform: 'wasm',
+            arch: 'wasm64',
+            runtime: 'st',
+            buildType: 'debug',
+            runtimeEnv: 'node',
+        },
+        {
+            platform: 'wasm',
+            arch: 'wasm64',
+            runtime: 'mt',
+            buildType: 'release',
+            runtimeEnv: 'browser',
+        },
+        {
+            platform: 'wasm',
+            arch: 'wasm64',
+            runtime: 'mt',
+            buildType: 'release',
+            runtimeEnv: 'node',
+        },
+        {
+            platform: 'wasm',
+            arch: 'wasm64',
+            runtime: 'mt',
+            buildType: 'debug',
+            runtimeEnv: 'browser',
+        },
+        {
+            platform: 'wasm',
+            arch: 'wasm64',
+            runtime: 'mt',
+            buildType: 'debug',
+            runtimeEnv: 'node',
+        },
+        {
+            platform: 'android',
+            arch: 'arm64-v8a',
+            runtime: 'mt',
+            buildType: 'release',
+        },
+        {
+            platform: 'android',
+            arch: 'arm64-v8a',
+            runtime: 'mt',
+            buildType: 'debug',
+        },
+        {
+            platform: 'android',
+            arch: 'x86_64',
+            runtime: 'mt',
+            buildType: 'release',
+        },
+        {
+            platform: 'android',
+            arch: 'x86_64',
+            runtime: 'mt',
+            buildType: 'debug',
+        },
+        {
+            platform: 'ios',
+            arch: 'iphoneos',
+            runtime: 'mt',
+            buildType: 'release',
+        },
+        {
+            platform: 'ios',
+            arch: 'iphoneos',
+            runtime: 'mt',
+            buildType: 'debug',
+        },
+        {
+            platform: 'ios',
+            arch: 'iphonesimulator',
+            runtime: 'mt',
+            buildType: 'release',
+        },
+        {
+            platform: 'ios',
+            arch: 'iphonesimulator',
+            runtime: 'mt',
+            buildType: 'debug',
+        },
+    ],
     config: null,
     cache: {
         hashes: {},
@@ -30,6 +186,19 @@ await initProcessState();
 async function initProcessState() {
     state.cache = loadCacheState();
     state.config = await loadConfig();
+
+    state.targets.forEach((target) => {
+        target.path = `${target.platform}-${target.arch}-${target.runtime}-${target.buildType}`;
+        target.releasePath = `${target.platform}-${target.arch}-${target.runtime}-release`;
+        if (target.runtimeEnv && target.platform === 'wasm') {
+            target.rawJsName = `${state.config.general.name}-${target.path}.js`;
+            target.jsName = `${state.config.general.name}-${target.path}.${target.runtimeEnv}.js`;
+            target.wasmName = `${state.config.general.name}-${target.path}.wasm`;
+            target.dataName = `${state.config.general.name}-${target.path}.data`;
+            target.dataTxtName = `${state.config.general.name}-${target.path}.data.txt`;
+        }
+    });
+
     setAllDependecyPaths();
     if (state.config.build?.setState) {
         state.config.build.setState(state);
@@ -43,23 +212,28 @@ function loadCacheState() {
 
 function setAllDependecyPaths() {
     state.config.allDependencyPaths = {};
-    state.platforms.All.forEach((platform) => {
-        const basePlatform = platform.split('-', 1)[0];
-        state.config.allDependencyPaths[platform] = { cmake: {} };
+    state.targets.forEach((target) => {
+        state.config.allDependencyPaths[target.path] = { cmake: {} };
         state.config.allDependencies.forEach((d) => {
-            state.config.allDependencyPaths[platform].cmake[d.general.name] = `${d.paths.output}/prebuilt`;
+            state.config.allDependencyPaths[target.path].cmake[d.general.name] = `${d.paths.output}/prebuilt`;
             d.export.libName.forEach((name) => {
-                state.config.allDependencyPaths[platform][name] = {
-                    root: `${d.paths.output}/prebuilt/${platform}`,
+                state.config.allDependencyPaths[target.path][name] = {
+                    root: `${d.paths.output}/prebuilt/${target.path}`,
                 };
-                const platformConfig = d.platform[platform] || {};
-                const isDynamicLib = basePlatform === 'Android' && platformConfig.libType !== 'static';
-                const dep = state.config.allDependencyPaths[platform][name];
-                if (basePlatform === 'iOS') {
+                const entryArray = d?.targetSpecs?.filter(t => (
+                    (!t.platform || t.platform === target.platform)
+                    && (!t.arch || t.arch === target.arch)
+                    && (!t.runtime || t.runtime === target.runtime)
+                    && (!t.buildType || t.buildType === target.buildType)
+                )).map(t => t?.specs);
+                const platformConfig = Object.assign({}, ...entryArray);
+                const isDynamicLib = target.platform === 'android' && platformConfig.libType !== 'static';
+                const dep = state.config.allDependencyPaths[target.path][name];
+                if (target.platform === 'ios') {
                     let xcRoot;
-                    if (platform === 'iOS-iphoneos') {
+                    if (target.arch === 'iphoneos') {
                         xcRoot = `${d.paths.project}/${name}.xcframework/ios-arm64_arm64e`;
-                    } else if (platform === 'iOS-iphonesimulator') {
+                    } else if (target.arch === 'iphonesimulator') {
                         xcRoot = `${d.paths.project}/${name}.xcframework/ios-arm64_x86_64-simulator`;
                     }
                     dep.header = `${xcRoot}/Headers`;

package/src/state/loadConfig.js

@@ -1,4 +1,5 @@
 import os from 'node:os';
+import fs from 'node:fs';
 import systemKeys from '../utils/systemKeys.js';
 import loadJs from '../utils/loadJs.js';
 import loadJson from '../utils/loadJson.js';
@@ -38,10 +39,12 @@ function getFilledConfig(config, options = { isDepend: false }) {
         paths: config.paths || {},
         ext: config.ext || {},
         export: config.export || {},
-        platform: config.platform || {},
+        targetSpecs: config.targetSpecs || [],
         build: config.build || {},
+        target: config.target || {},
         extensions: config.extensions || [],
         package: null,
+        functions: config.functions || {},
     };
 
     if (newConfig.paths.config && !newConfig.paths.project) {
@@ -88,14 +91,6 @@ function getFilledConfig(config, options = { isDepend: false }) {
     newConfig.export.libName = newConfig.export.libName || [newConfig.general.name];
     newConfig.export.binHeaders = newConfig.export.binHeaders || [];
 
-    newConfig.platform['Emscripten-x86_64'] = newConfig.platform['Emscripten-x86_64'] || {};
-    newConfig.platform['Emscripten-x86_64-browser'] = newConfig.platform['Emscripten-x86_64-browser'] || {};
-    newConfig.platform['Emscripten-x86_64-node'] = newConfig.platform['Emscripten-x86_64-node'] || {};
-    newConfig.platform['Android-arm64-v8a'] = newConfig.platform['Android-arm64-v8a'] || {};
-    newConfig.platform['Android-x86_64'] = newConfig.platform['Android-x86_64'] || {};
-    newConfig.platform['iOS-iphoneos'] = newConfig.platform['iOS-iphoneos'] || {};
-    newConfig.platform['iOS-iphonesimulator'] = newConfig.platform['iOS-iphonesimulator'] || {};
-
     newConfig.allDependencies = (() => {
         const output = {};
         [...newConfig.dependencies, ...newConfig.dependencies.map((d) => d.allDependencies).flat()].forEach((d) => {
@@ -108,12 +103,18 @@ function getFilledConfig(config, options = { isDepend: false }) {
         e?.loadConfig?.after(newConfig);
     });
 
-    newConfig.build.usePthread = newConfig.build.usePthread || false;
-
-    if (!newConfig.build.usePthread) {
-        newConfig.build.usePthread = newConfig.allDependencies.some((d) => d?.build?.usePthread);
+    if (newConfig.target.runtime !== 'mt' && newConfig.allDependencies.some((d) => d?.target?.runtime === 'mt')) {
+        newConfig.target.runtime = 'mt';
     }
 
+    newConfig.functions.isEnabled = newConfig.functions.isEnabled || ((target) => {
+        return (
+            fs.existsSync(`${newConfig.paths.cmakeDir}/${target.path}`)
+            || fs.existsSync(`${newConfig.paths.cmakeDir}/${target.releasePath}`)
+            || (target.platform === 'ios' && fs.existsSync(`${newConfig.paths.cmakeDir}/../../${newConfig.general.name}-${target.runtime}.xcframework`))
+        );
+    });
+
     newConfig.dependencyParameters = calculateDependencyParameters(newConfig);
     // newConfig.cmakeParameters = getCmakeParameters(newConfig);