cpp.js 0.6.1 → 1.0.0-alpha.3

package/src/functions/createWasm.js

@@ -1,199 +1,68 @@
-import { execFileSync } from 'child_process';
-import glob from 'glob';
-import pullDockerImage, { getDockerImage } from '../utils/pullDockerImage.js';
-import getBaseInfo from '../utils/getBaseInfo.js';
+import fs from 'fs';
+import buildJS from './buildJS.js';
+import run from './run.js';
+import getCmakeParams from './getCmakeParams.js';
+import getLibs from './getLibs.js';
+import getData from './getData.js';
 import getPathInfo from '../utils/getPathInfo.js';
-import getOsUserAndGroupId from '../utils/getOsUserAndGroupId.js';
-import { getCliCMakeListsFile } from '../utils/findCMakeListsFile.js'
 
-export default function createWasm(compiler, options = {}) {
-    const compiler2 = new CppjsCompiler(
-        compiler.config,
-        options,
-    );
-    return compiler2.compileToWasm();
-}
-
-export function getCmakeParams(compiler, options = {}) {
-    const compiler2 = new CppjsCompiler(
-        compiler.config,
-        options,
-    );
-
-    compiler2.prepare();
-    return compiler2.getCmakeParams(compiler.config.general.name, true, true);
-}
-
-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]);
+export default async function createWasm(compiler, options, buildAll = false) {
+    const output = `/tmp/cppjs/live/${getPathInfo(compiler.config.paths.temp, compiler.config.paths.base).relative}`;
+
+    let params = getCmakeParams(compiler.config, '/tmp/cppjs/live/', true, false);
+    run(compiler, 'emcmake', [
+        'cmake', '/tmp/cppjs/cmake',
+        '-DCMAKE_BUILD_TYPE=Release', '-DBUILD_TYPE=STATIC',
+        `-DCMAKE_INSTALL_PREFIX=${output}`, `-DPROJECT_NAME=${compiler.config.general.name}`,
+        ...params,
+    ]);
+    run(compiler, 'emmake', ['make', 'install']);
+
+    params = getCmakeParams(compiler.config, '/tmp/cppjs/live/', false, true);
+    run(compiler, 'emcmake', [
+        'cmake', '/tmp/cppjs/cmake',
+        '-DCMAKE_BUILD_TYPE=Release', '-DBUILD_TYPE=STATIC',
+        `-DCMAKE_INSTALL_PREFIX=${output}`, `-DPROJECT_NAME=${compiler.config.general.name}bridge`,
+        ...params,
+    ]);
+    run(compiler, 'emmake', ['make', 'install']);
+
+    const libs = getLibs(compiler.config, '/tmp/cppjs/live/');
+    const data = Object.entries(getData(compiler.config, 'data', '/tmp/cppjs/live/', 'Emscripten-x86_64', 'browser')).map(([key, value]) => ['--preload-file', `${key}@${value}`]).flat();
+    run(compiler, 'emcc', [
+        '-lembind', '-Wl,--whole-archive',
+        ...libs, ...(options.cc || []),
+        '-s', 'WASM=1', '-s', 'MODULARIZE=1',
+        '-s', 'RESERVED_FUNCTION_POINTERS=200', '-s', 'DISABLE_EXCEPTION_CATCHING=0', '-s', 'FORCE_FILESYSTEM=1',
+        '-s', 'TOTAL_MEMORY=512MB', '-s', 'ALLOW_MEMORY_GROWTH=1',
+        '-s', 'EXPORTED_RUNTIME_METHODS=["FS", "ENV"]',
+        '-o', `${output}/${compiler.config.general.name}.js`,
+        ...data,
+    ]);
+    await buildJS(compiler, `${output}/${compiler.config.general.name}.js`, 'browser');
+    run(compiler, 'emcc', [
+        '-lembind', '-Wl,--whole-archive', '-lnodefs.js',
+        ...libs, ...(options.cc || []),
+        '-s', 'WASM=1', '-s', 'MODULARIZE=1',
+        '-s', 'RESERVED_FUNCTION_POINTERS=200', '-s', 'DISABLE_EXCEPTION_CATCHING=0', '-s', 'FORCE_FILESYSTEM=1', '-s', 'NODERAWFS',
+        '-s', 'TOTAL_MEMORY=512MB', '-s', 'ALLOW_MEMORY_GROWTH=1',
+        '-s', 'EXPORTED_RUNTIME_METHODS=["FS", "ENV", "NODEFS"]',
+        '-o', `${output}/${compiler.config.general.name}.js`,
+    ]);
+    Object.entries(getData(compiler.config, 'data', null, 'Emscripten-x86_64', 'node')).forEach(([key, value]) => {
+        if (fs.existsSync(key)) {
+            const dAssetPath = `${output}/data/${value}`;
+            if (!fs.existsSync(dAssetPath)) {
+                fs.mkdirSync(dAssetPath, { recursive: true });
+                fs.cpSync(key, dAssetPath, { recursive: true });
+            }
         }
-    }
-
-    dependency.dependencies.forEach(dep => {
-        setPath(arr, dep, type, filter);
     });
-}
-
-function getParentPath(path) {
-    const pathArray = path.split('/');
-    pathArray.pop();
-    return pathArray.join('/');
-}
-
-
-class CppjsCompiler {
-    constructor(config, options) {
-        this.config = config;
-        this.options = options;
-        this.pathType = 'absolute';
-        this.pathPrefix = '';
-    }
-
-    getPath(path) {
-        if (this.pathType === 'absolute') {
-            return getPathInfo(path, this.config.paths.base).absolute;
-        } else if (this.pathType === 'relative') {
-            return `${this.pathPrefix}${getPathInfo(path, this.config.paths.base).relative}`
-        }
-
-        return '';
-    }
-
-    compileToWasm() {
-        pullDockerImage();
-
-        this.pathType = 'relative';
-        this.pathPrefix = '/live/';
-
-        this.prepare();
-        this.cmake(this.config.general.name, true, false);
-        this.make();
-        this.cmake(this.config.general.name+'bridge', false, true);
-        this.make();
-
-        const dependLibs = [
-            ...glob.sync(`${this.config.paths.temp}/dependencies/**/*.a`, { absolute: true, cwd: this.config.paths.project }),
-        ];
-        this.cmakeDepends.forEach((d) => {
-            dependLibs.push(...glob.sync(`${d.paths.output}/prebuilt/Emscripten-x86_64/**/*.a`, { absolute: true, cwd: d.paths.project }));
-        });
-
-        this.libs = [
-            `${this.config.paths.temp}/lib${this.config.general.name}.a`,
-            `${this.config.paths.temp}/lib${this.config.general.name}bridge.a`,
-            ...dependLibs,
-        ].filter(path => !!path.toString()).map(path => this.getPath(path));
-
-        this.cc();
-
-        return this.config.paths.temp;
-    }
-
-    prepare() {
-        const sourceFilter = (d) => d === this.config || d.export.type === 'source';
-        this.headerPathWithDepends = [];
-        setPath(this.headerPathWithDepends, this.config, 'header', sourceFilter);
-        this.headerPathWithDepends = this.headerPathWithDepends.map(p => this.getPath(p)).join(';');
-
-        this.headerGlob = [];
-        this.headerPathWithDepends.split(';').forEach(h => {
-            this.config.ext.header.forEach(ext => {
-                this.headerGlob.push(`${h}/*.${ext}`);
-            });
-        });
-
-
-        this.nativePathWithDepends = [];
-        setPath(this.nativePathWithDepends, this.config, 'native', sourceFilter);
-        this.nativePathWithDepends = this.nativePathWithDepends.map(p => this.getPath(p)).join(';');
-
-        this.nativeGlob = [];
-        this.nativePathWithDepends.split(';').forEach(h => {
-            this.config.ext.source.forEach(ext => {
-                this.nativeGlob.push(`${h}/*.${ext}`);
-            });
-        });
-
-        const cliCMakeListsFile = getCliCMakeListsFile();
-        const cmakeFilter = (d) => d !== this.config && d.export.type === 'cmake' && d.paths.cmake !== cliCMakeListsFile;
-        this.cmakeDepends = [];
-        setPath(this.cmakeDepends, this.config, 'this', cmakeFilter);
-
-        this.pathsOfCmakeDepends = this.cmakeDepends
-            .map(d => getParentPath(d.paths.cmake))
-            .map(p => this.getPath(p)).join(';');
-        this.nameOfCmakeDepends = this.cmakeDepends.map(d => d.general.name).join(';');
+    await buildJS(compiler, `${output}/${compiler.config.general.name}.js`, 'node');
+    // await buildJS(compiler, `${output}/${compiler.config.general.name}.js`);
+    if (fs.existsSync(`${compiler.config.paths.temp}/${compiler.config.general.name}.data`)) {
+        fs.renameSync(`${compiler.config.paths.temp}/${compiler.config.general.name}.data`, `${compiler.config.paths.temp}/${compiler.config.general.name}.data.txt`);
     }
 
-    getCmakeParams(name, isBuildSource, isBuildBridge) {
-        const params = [];
-        if (isBuildSource) params.push('-DBUILD_SOURCE=TRUE');
-        if (isBuildBridge) params.push('-DBUILD_BRIDGE=TRUE');
-
-        const output = this.getPath(this.config.paths.temp);
-        const projectPath = this.getPath(process.cwd());
-
-        params.push(...[
-            `-DBASE_DIR=${projectPath}`,
-            `-DNATIVE_GLOB=${this.nativeGlob.join(';')}`,
-            `-DHEADER_GLOB=${this.headerGlob.join(';')}`,
-            `-DHEADER_DIR=${this.headerPathWithDepends}`,
-            `-DDEPENDS_CMAKE_PATHS=${this.pathsOfCmakeDepends}`,
-            `-DDEPENDS_CMAKE_NAMES=${this.nameOfCmakeDepends}`,
-            `-DBRIDGE_DIR=${output}/bridge`,
-        ]);
-
-        return params;
-    }
-
-    cmake(name, isBuildSource, isBuildBridge) {
-        const params = this.getCmakeParams(name, isBuildSource, isBuildBridge);
-
-        const output = this.getPath(this.config.paths.temp);
-        const base = getBaseInfo(this.config.paths.base);
-
-        const cMakeParentPath = getParentPath(this.config.paths.cmake);
-
-        const args = [
-            "run", "--user", getOsUserAndGroupId(), "-v", `${base.withoutSlash}:/live`, "-v", `${cMakeParentPath}:/cmake`, "--workdir", `${output}`, getDockerImage(),
-            "emcmake", "cmake", "/cmake", '-DCMAKE_BUILD_TYPE=Release', '-DBUILD_TYPE=STATIC', `-DCMAKE_INSTALL_PREFIX=${output}`, `-DPROJECT_NAME=${name}`, ...params,
-        ];
-        const options = { cwd: this.config.paths.temp, stdio : 'pipe' };
-        execFileSync("docker", args, options);
-        return this.config.paths.temp;
-    }
-
-    make() {
-        const output = this.getPath(this.config.paths.temp);
-        const base = getBaseInfo(this.config.paths.base);
-
-        let cMakeParentPath = this.config.paths.cmake.split('/');
-        cMakeParentPath.pop();
-        cMakeParentPath = cMakeParentPath.join('/');
-        const args = [
-            "run", "--user", getOsUserAndGroupId(), "-v", `${base.withoutSlash}:/live`, "-v", `${cMakeParentPath}:/cmake`, "--workdir", `${output}`, getDockerImage(),
-            "emmake", "make", "install"
-        ];
-        const options = { cwd: this.config.paths.temp, stdio : 'pipe' };
-        execFileSync("docker", args, options);
-        return this.config.paths.temp;
-    }
-
-    cc() {
-        const output = this.getPath(this.config.paths.temp);
-        const base = getBaseInfo(this.config.paths.base);
-        const args = [
-            "run", "--user", getOsUserAndGroupId(), "-v", `${base.withoutSlash}:/live`, "-v", `${this.config.paths.cli}:/cli`, getDockerImage(),
-            "emcc", "-lembind", "-Wl,--whole-archive", ...this.libs, ...(this.options.cc || []), "-s", "WASM=1", "-s", "MODULARIZE=1", '-o', `${output}/${this.config.general.name}.js`, '--extern-post-js', '/cli/assets/extern-post.js'
-        ];
-        const options = { cwd: this.config.paths.temp, stdio : 'pipe' };
-        execFileSync("docker", args, options);
-        return this.config.paths.temp;
-    }
+    return compiler.config.paths.temp;
 }

package/src/functions/findOrCreateInterfaceFile.js

@@ -1,28 +1,49 @@
+/* eslint-disable prefer-destructuring */
 import fs from 'fs';
 import getBaseInfo from '../utils/getBaseInfo.js';
 import getPathInfo from '../utils/getPathInfo.js';
+import { getDependencyParams } from './getCmakeParams.js';
 
 export default function findOrCreateInterfaceFile(compiler, filePath) {
+    const moduleRegex = new RegExp(`.(${compiler.config.ext.module.join('|')})$`);
+    if (moduleRegex.test(filePath) && fs.existsSync(filePath)) {
+        const newPath = `${compiler.config.paths.temp}/interface/${filePath.split('/').pop()}`;
+        fs.copyFileSync(filePath, newPath);
+        compiler.interfaces.push(newPath);
+        return filePath;
+    }
+
     const input = getPathInfo(filePath, compiler.config.paths.base);
-    const output = getPathInfo(compiler.config.paths.temp+'/interface', compiler.config.paths.base);
+    const output = getPathInfo(`${compiler.config.paths.temp}/interface`, compiler.config.paths.base);
     const base = getBaseInfo(compiler.config.paths.base);
 
+    const headerPaths = (getDependencyParams(compiler.config)?.pathsOfCmakeDepends?.split(';') || [])
+        .filter((d) => d.startsWith(compiler.config.paths.base))
+        .map((d) => d.replace(`${compiler.config.paths.base}/`, ''));
+
+    const temp2 = headerPaths
+        .map((p) => input.relative.match(new RegExp(`^${p}/.*?/include/(.*?)$`, 'i')))
+        .filter((p) => p && p.length === 2);
+
     const temp = input.relative.match(/^(.*)\..+?$/);
     if (temp.length < 2) return null;
 
     const filePathWithoutExt = temp[1];
-    const interfaceFile = filePathWithoutExt + '.i';
+    const interfaceFile = `${compiler.config.paths.base}/${filePathWithoutExt}.i`;
 
-    if (fs.existsSync(interfaceFile)) return interfaceFile;
+    if (fs.existsSync(interfaceFile)) {
+        compiler.interfaces.push(interfaceFile);
+        return interfaceFile;
+    }
 
     const fileName = filePathWithoutExt.split('/').at(-1);
 
-    let headerPath = compiler.config.paths.header.find(path => filePath.startsWith(path));
-    if (headerPath) headerPath = filePath.substr(headerPath.length+1);
+    let headerPath = compiler.config.paths.header.find((path) => filePath.startsWith(path));
+    if (headerPath) headerPath = filePath.substr(headerPath.length + 1);
+    else if (temp2 && temp2.length > 0) headerPath = temp2[0][1];
     else headerPath = input.relative.split('/').at(-1);
 
-    const content =
-`#ifndef _${fileName.toUpperCase()}_I
+    const content = `#ifndef _${fileName.toUpperCase()}_I
 #define _${fileName.toUpperCase()}_I
 
 %module ${fileName.toUpperCase()}
@@ -38,7 +59,7 @@ export default function findOrCreateInterfaceFile(compiler, filePath) {
 
 #endif
 `;
-    const outputFilePath = base.withSlash + output.relative+'/'+fileName+'.i';
+    const outputFilePath = `${base.withSlash + output.relative}/${fileName}.i`;
     fs.writeFileSync(outputFilePath, content);
 
     compiler.interfaces.push(outputFilePath);

package/src/functions/finishBuild.js

@@ -0,0 +1,43 @@
+import fs from 'fs';
+import { execFileSync } from 'child_process';
+import getPathInfo from '../utils/getPathInfo.js';
+
+export default function finishBuild(compiler) {
+    const output = getPathInfo(compiler.config.paths.output, compiler.config.paths.base);
+    if (
+        !fs.existsSync(`${output.absolute}/prebuilt/iOS-iphoneos/lib`)
+        || !fs.existsSync(`${output.absolute}/prebuilt/iOS-iphonesimulator/lib`)
+    ) return;
+
+    const options = {
+        cwd: `${output.absolute}/prebuilt`,
+        stdio: 'inherit',
+    };
+
+    compiler.config.export.libName.forEach((fileName) => {
+        if (!fs.existsSync(`${options.cwd}/${fileName}.xcframework`)) {
+            const params = [
+                '-create-xcframework',
+                '-library', `iOS-iphoneos/lib/lib${fileName}.a`,
+                '-headers', 'iOS-iphoneos/include',
+                '-library', `iOS-iphonesimulator/lib/lib${fileName}.a`,
+                '-headers', 'iOS-iphonesimulator/include',
+                '-output', `${fileName}.xcframework`,
+            ];
+            execFileSync('xcodebuild', params, options);
+        }
+
+        if (!fs.existsSync(`${options.cwd}/${fileName}.xcframework.zip`)) {
+            execFileSync('zip', ['-y', '-r', `./${fileName}.xcframework.zip`, `${fileName}.xcframework`], options);
+        }
+        if (!fs.existsSync(`${compiler.config.paths.project}/${fileName}.xcframework`)) {
+            fs.symlinkSync(`${options.cwd}/${fileName}.xcframework`, `${compiler.config.paths.project}/${fileName}.xcframework`);
+        }
+    });
+    /* if (fs.existsSync(`${output.absolute}/prebuilt/iOS-iphoneos`)) {
+        fs.rmSync(`${output.absolute}/prebuilt/iOS-iphoneos`, { recursive: true, force: true });
+    }
+    if (fs.existsSync(`${output.absolute}/prebuilt/iOS-iphonesimulator`)) {
+        fs.rmSync(`${output.absolute}/prebuilt/iOS-iphonesimulator`, { recursive: true, force: true });
+    } */
+}

package/src/functions/getCmakeParams.js

@@ -0,0 +1,106 @@
+import getPathInfo from '../utils/getPathInfo.js';
+import { getCliCMakeListsFile } from '../utils/findCMakeListsFile.js';
+
+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('/');
+}
+
+function getPath(config, path, pathPrefix) {
+    if (!pathPrefix) {
+        return getPathInfo(path, config.paths.base).absolute;
+    }
+
+    return `${pathPrefix}${getPathInfo(path, config.paths.base).relative}`;
+}
+
+const dependencyParams = {};
+export function getDependencyParams(config, pathPrefix) {
+    if (dependencyParams && dependencyParams[pathPrefix || 'empty']) {
+        return dependencyParams[pathPrefix || 'empty'];
+    }
+
+    const sourceFilter = (d) => d === config || d.export.type === 'source';
+    let headerPathWithDepends = [];
+    setPath(headerPathWithDepends, config, 'header', sourceFilter);
+    headerPathWithDepends = [...new Set(headerPathWithDepends.map((p) => getPath(config, p, pathPrefix)))].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.map((p) => getPath(config, p, pathPrefix)))].join(';');
+
+    const nativeGlob = [];
+    nativePathWithDepends.split(';').forEach((h) => {
+        config.ext.source.forEach((ext) => {
+            nativeGlob.push(`${h}/*.${ext}`);
+        });
+    });
+
+    const cliCMakeListsFile = getCliCMakeListsFile();
+    const cmakeFilter = (d) => d !== config && d.export.type === 'cmake' && d.paths.cmake !== cliCMakeListsFile;
+    let cmakeDepends = [];
+    setPath(cmakeDepends, config, 'this', cmakeFilter);
+    cmakeDepends = [...new Set(cmakeDepends)];
+
+    const pathsOfCmakeDepends = [...new Set(cmakeDepends
+        .map((d) => getParentPath(d.paths.cmake))
+        .map((p) => getPath(config, p, pathPrefix)))].join(';');
+    const nameOfCmakeDepends = [...new Set(cmakeDepends.map((d) => d.general.name))].join(';');
+
+    dependencyParams[pathPrefix || 'empty'] = {
+        nativeGlob,
+        headerGlob,
+        headerPathWithDepends,
+        cmakeDepends,
+        pathsOfCmakeDepends,
+        nameOfCmakeDepends,
+    };
+    return dependencyParams[pathPrefix || 'empty'];
+}
+
+export default function getCmakeParams(config, pathPrefix, isBuildSource, isBuildBridge) {
+    const params = [];
+    if (isBuildSource) params.push('-DBUILD_SOURCE=TRUE');
+    if (isBuildBridge) params.push('-DBUILD_BRIDGE=TRUE');
+
+    const output = getPath(config, config.paths.temp, pathPrefix);
+    const projectPath = getPath(config, process.cwd(), pathPrefix);
+
+    const dependParams = getDependencyParams(config, pathPrefix);
+
+    params.push(...[
+        `-DBASE_DIR=${projectPath}`,
+        `-DNATIVE_GLOB=${dependParams.nativeGlob.join(';')}`,
+        `-DHEADER_GLOB=${dependParams.headerGlob.join(';')}`,
+        `-DHEADER_DIR=${dependParams.headerPathWithDepends}`,
+        `-DDEPENDS_CMAKE_PATHS=${dependParams.pathsOfCmakeDepends}`,
+        `-DDEPENDS_CMAKE_NAMES=${dependParams.nameOfCmakeDepends}`,
+        `-DBRIDGE_DIR=${output}/bridge`,
+    ]);
+
+    return params;
+}

package/src/functions/getData.js

@@ -0,0 +1,37 @@
+/* eslint-disable default-param-last */
+/* eslint-disable no-param-reassign */
+import getPathInfo from '../utils/getPathInfo.js';
+
+function getPath(config, path, pathPrefix) {
+    if (!pathPrefix) {
+        return getPathInfo(path, config.paths.base).absolute;
+    }
+
+    return `${pathPrefix}${getPathInfo(path, config.paths.base).relative}`;
+}
+
+function getRecursiveData(obj, dependency, field, pathPrefix, platform, subPlatform) {
+    const platformName = subPlatform ? `${platform}-${subPlatform}` : platform;
+    if (dependency?.platform?.[platformName]?.[field]) {
+        Object.entries(dependency.platform[platformName][field]).forEach(([dKey, value]) => {
+            if (field === 'data') {
+                const a = `${dependency.paths.project}/dist/prebuilt/${platform}/${dKey}`;
+                const key = getPath(dependency, a, pathPrefix);
+                obj[key] = value;
+            } else {
+                obj[dKey] = value;
+            }
+        });
+    }
+
+    dependency.dependencies.forEach((dep) => {
+        getRecursiveData(obj, dep, field, pathPrefix, platform, subPlatform);
+    });
+}
+
+export default function getData(config, field, pathPrefix, platform = 'Emscripten-x86_64', subPlatform) {
+    const output = {};
+    getRecursiveData(output, config, field, pathPrefix, platform, subPlatform);
+
+    return output;
+}

package/src/functions/getLibs.js

@@ -0,0 +1,33 @@
+import glob from 'glob';
+import getPathInfo from '../utils/getPathInfo.js';
+import { getDependencyParams } from './getCmakeParams.js';
+
+function getPath(config, path, pathPrefix) {
+    if (!pathPrefix) {
+        return getPathInfo(path, config.paths.base).absolute;
+    }
+
+    return `${pathPrefix}${getPathInfo(path, config.paths.base).relative}`;
+}
+
+export default function getLibs(config, pathPrefix) {
+    let dependLibs = [
+        ...glob.sync(`${config.paths.temp}/dependencies/**/*.a`, { absolute: true, cwd: config.paths.project }),
+    ];
+    getDependencyParams(config, pathPrefix).cmakeDepends.forEach((d) => {
+        if (d.export.libName) {
+            d.export.libName.forEach((fileName) => {
+                if (d.platform['Emscripten-x86_64'].ignoreLibName?.includes(fileName)) return;
+                dependLibs.push(...glob.sync(`${d.paths.output}/prebuilt/Emscripten-x86_64/lib/lib${fileName}.a`, { absolute: true, cwd: d.paths.project }));
+            });
+        }
+    });
+
+    dependLibs = [...new Set(dependLibs)];
+
+    return [...new Set([
+        `${config.paths.temp}/lib${config.general.name}.a`,
+        `${config.paths.temp}/lib${config.general.name}bridge.a`,
+        ...dependLibs,
+    ].filter((path) => !!path.toString()).map((path) => getPath(config, path, pathPrefix)))];
+}