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

package/src/utils/fixPackageName.js

@@ -0,0 +1,7 @@
+export default function fixPackageName(name) {
+    if (!name) {
+        return null;
+    }
+
+    return name.replace(/[^a-zA-Z0-9-_]+/g, '');
+}

package/src/utils/getAbsolutePath.js

@@ -0,0 +1,14 @@
+import upath from 'upath';
+
+export default function getAbsolutePath(projectPath, path) {
+    if (!path) {
+        return null;
+    }
+    if (upath.isAbsolute(path)) {
+        return path;
+    }
+    if (projectPath) {
+        return upath.resolve(upath.join(upath.resolve(projectPath), path));
+    }
+    return upath.resolve(path);
+}

package/src/utils/{findCMakeListsFile.js → getCMakeListsFilePath.js}

@@ -1,7 +1,7 @@
 import glob from 'glob';
-import getCliPath from './getCliPath.js';
+import getParentPath from './getParentPath.js';
 
-export default function findCMakeListsFile(basePath = process.cwd()) {
+export default function getCMakeListsFilePath(basePath = process.cwd()) {
     let temp = glob.sync('CMakeLists.txt', { absolute: true, cwd: basePath });
     if (temp.length === 0) {
         temp = glob.sync('*/CMakeLists.txt', { absolute: true, cwd: basePath, ignore: ['node_modules/*', 'dist/*', 'build/*'] });
@@ -12,5 +12,6 @@ export default function findCMakeListsFile(basePath = process.cwd()) {
 }
 
 export function getCliCMakeListsFile() {
-    return `${getCliPath()}/assets/CMakeLists.txt`;
+    const cliPath = getParentPath(getParentPath(import.meta.url));
+    return `${cliPath}/assets/CMakeLists.txt`;
 }

package/src/utils/getOsUserAndGroupId.js

@@ -4,7 +4,8 @@ let osUserAndGroupId;
 export default function getOsUserAndGroupId() {
     const userInfo = os.userInfo();
     if (!osUserAndGroupId) {
-        osUserAndGroupId = `${userInfo.uid}:${userInfo.gid}`;
+        const isInvalid = userInfo.uid === -1 && userInfo.gid === -1;
+        osUserAndGroupId = isInvalid ? '0:0' : `${userInfo.uid}:${userInfo.gid}`;
     }
     return osUserAndGroupId;
 }

package/src/utils/getParentPath.js

@@ -0,0 +1,12 @@
+import * as url from 'node:url';
+import upath from 'upath';
+
+export default function getParentPath(importUrl) {
+    let input = importUrl;
+    try {
+        input = url.fileURLToPath(input);
+    } catch (e) { /* empty */ }
+    const filename = upath.normalize(input);
+    const temp = filename.split('/'); temp.pop();
+    return temp.join('/');
+}

package/src/utils/hash.js

@@ -0,0 +1,20 @@
+import fs from 'node:fs';
+import { createHash } from 'node:crypto';
+
+export function getFileHash(path) {
+    const data = fs.readFileSync(path);
+    return getContentHash(data);
+    /* return new Promise((resolve, reject) => {
+        const hash = createHash('sha256');
+        const rs = fs.createReadStream(path);
+        rs.on('error', reject);
+        rs.on('data', (chunk) => hash.update(chunk));
+        rs.on('end', () => resolve(hash.digest('hex')));
+    }); */
+}
+
+export function getContentHash(content) {
+    const hash = createHash('sha256');
+    hash.update(content);
+    return hash.digest('hex');
+}

package/src/utils/loadJs.js

@@ -0,0 +1,32 @@
+import fs from 'node:fs';
+
+export default async function loadJs(path, fileName, fileExt = ['json', 'js', 'mjs', 'cjs', 'ts']) {
+    let filePath;
+    fileExt.some((e) => {
+        filePath = `${path}/${fileName}.${e}`;
+        if (!fs.existsSync(filePath)) {
+            filePath = null;
+            return false;
+        }
+        return true;
+    });
+
+    if (filePath) {
+        let file;
+        if (typeof module !== 'undefined' && module.exports) {
+            file = require(`file:///${filePath}`);
+        } else {
+            file = await import(`file:///${filePath}`);
+        }
+        if (file.default) file = file.default;
+
+        if (typeof file === 'function') {
+            return file();
+        }
+        if (typeof file === 'object') {
+            return file;
+        }
+    }
+
+    return null;
+}

package/src/utils/loadJson.js

@@ -0,0 +1,16 @@
+import fs from 'node:fs';
+
+export default function loadJson(filePath) {
+    if (!fs.existsSync(filePath)) {
+        return null;
+    }
+
+    try {
+        const stateContent = fs.readFileSync(filePath, { encoding: 'utf8', flag: 'r' });
+        const state = JSON.parse(stateContent);
+        return state;
+    } catch (e) {
+        console.error(e);
+        return null;
+    }
+}

package/src/utils/pullDockerImage.js

@@ -3,7 +3,7 @@ import { execFileSync } from 'child_process';
 let isDockerImageAvailable = false;
 
 export function getDockerImage() {
-    return 'bugra9/cpp.js:0.2.6';
+    return 'bugra9/cpp.js:0.2.8';
 }
 
 export default function pullDockerImage() {

package/src/utils/writeJson.js

@@ -0,0 +1,9 @@
+import fs from 'node:fs';
+
+export default function writeJson(filePath, data) {
+    try {
+        fs.writeFileSync(filePath, JSON.stringify(data, null, 4));
+    } catch (e) {
+        console.error(e);
+    }
+}

package/.mocharc.yaml

@@ -1,3 +0,0 @@
-spec:
-  - 'src/**/*.spec.js'
-  - 'test/*.spec.js'

package/src/functions/createBridge.js

@@ -1,37 +0,0 @@
-import getBaseInfo from '../utils/getBaseInfo.js';
-import getPathInfo from '../utils/getPathInfo.js';
-import { getDependencyParams } from './getCmakeParams.js';
-import run from './run.js';
-
-const platform = 'Emscripten-x86_64';
-
-export default function createBridge(compiler) {
-    const bridges = [];
-
-    const allHeaders = getDependencyParams(compiler.config).headerPathWithDepends.split(';');
-
-    let includePath = [
-        ...compiler.config.getAllDependencies().map((d) => `${d.paths.output}/prebuilt/${platform}/include`),
-        ...compiler.config.getAllDependencies().map((d) => `${d.paths.output}/prebuilt/${platform}/swig`),
-        ...compiler.config.paths.header,
-        ...allHeaders,
-    ].filter((path) => !!path.toString()).map((path) => `-I/tmp/cppjs/live/${getPathInfo(path, compiler.config.paths.base).relative}`);
-    includePath = [...new Set(includePath)];
-
-    compiler.interfaces.forEach((filePath) => {
-        const input = getPathInfo(filePath, compiler.config.paths.base);
-        const output = getPathInfo(`${compiler.config.paths.temp}/bridge`, compiler.config.paths.base);
-        const base = getBaseInfo(compiler.config.paths.base);
-
-        run(compiler, 'swig', [
-            '-c++',
-            '-embind',
-            '-o', `/tmp/cppjs/live/${output.relative}/${filePath.split('/').at(-1)}.cpp`,
-            ...includePath,
-            `/tmp/cppjs/live/${input.relative}`,
-        ]);
-
-        bridges.push(`${base.withSlash}${output.relative}/${filePath.split('/').at(-1)}.cpp`);
-    });
-    return bridges;
-}

package/src/functions/createLib.js

@@ -1,44 +0,0 @@
-import fs from 'fs';
-import os from 'os';
-import getCmakeParams from './getCmakeParams.js';
-import getPathInfo from '../utils/getPathInfo.js';
-
-const cpuCount = os.cpus().length - 1;
-
-export default function createLib(compiler) {
-    if (!compiler.platform) return;
-
-    let platformParams = [];
-    switch (compiler.platform) {
-        case 'Emscripten-x86_64':
-            platformParams = ['-DBUILD_TYPE=STATIC'];
-            break;
-        case 'Android-arm64-v8a':
-            platformParams = ['-DBUILD_TYPE=SHARED'];
-            break;
-        case 'iOS-iphoneos':
-            platformParams = ['-DBUILD_TYPE=STATIC'];
-            break;
-        case 'iOS-iphonesimulator':
-            platformParams = ['-DBUILD_TYPE=STATIC'];
-            break;
-        default:
-    }
-
-    const libdir = `${getPathInfo(compiler.config.paths.output, compiler.config.paths.base).relative}/prebuilt/${compiler.platform}`;
-    const basePlatform = compiler.platform.split('-', 1)[0];
-    const params = getCmakeParams(compiler.config, '/tmp/cppjs/live/', true, false);
-    compiler.run(null, [
-        basePlatform === 'iOS' ? 'ios-cmake' : 'cmake', '/tmp/cppjs/cmake',
-        '-DCMAKE_BUILD_TYPE=Release', ...platformParams,
-        `-DCMAKE_INSTALL_PREFIX=/tmp/cppjs/live/${libdir}`, `-DPROJECT_NAME=${compiler.config.general.name}`,
-        ...params,
-    ]);
-    if (basePlatform === 'iOS') {
-        compiler.run(null, ['ios-cmake', '--build', '.', '--config', 'Release', '--target', 'install']);
-    } else {
-        compiler.run(null, ['make', `-j${cpuCount}`, 'install']);
-    }
-
-    fs.rmSync(compiler.config.paths.temp, { recursive: true, force: true });
-}

package/src/functions/createWasm.js

@@ -1,71 +0,0 @@
-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';
-
-export default async function createWasm(compiler, options = {}, buildAll = false) {
-    if (fs.existsSync('/tmp/cppjs/live')) fs.unlinkSync('/tmp/cppjs/live');
-    fs.symlinkSync(compiler.config.paths.base, '/tmp/cppjs/live');
-
-    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.replaceAll('@', '@@')}@${value}`]).flat();
-    run(compiler, 'emcc', [
-        '-lembind', '-Wl,--whole-archive',
-        ...libs, ...(options.cc || []),
-        '-s', 'WASM=1', '-s', 'MODULARIZE=1', '-s', 'DYNAMIC_EXECUTION=0',
-        '-s', 'RESERVED_FUNCTION_POINTERS=200', '-s', 'DISABLE_EXCEPTION_CATCHING=0', '-s', 'FORCE_FILESYSTEM=1',
-        '-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', 'DYNAMIC_EXECUTION=0',
-        '-s', 'RESERVED_FUNCTION_POINTERS=200', '-s', 'DISABLE_EXCEPTION_CATCHING=0', '-s', 'FORCE_FILESYSTEM=1', '-s', 'NODERAWFS',
-        '-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 });
-            }
-        }
-    });
-    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`);
-    }
-
-    return compiler.config.paths.temp;
-}

package/src/functions/findOrCreateInterfaceFile.js

@@ -1,68 +0,0 @@
-/* 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 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 = `${compiler.config.paths.base}/${filePathWithoutExt}.i`;
-
-    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);
-    else if (temp2 && temp2.length > 0) headerPath = temp2[0][1];
-    else headerPath = input.relative.split('/').at(-1);
-
-    const content = `#ifndef _${fileName.toUpperCase()}_I
-#define _${fileName.toUpperCase()}_I
-
-%module ${fileName.toUpperCase()}
-
-%{
-#include "${headerPath}"
-%}
-
-%feature("shared_ptr");
-%feature("polymorphic_shared_ptr");
-
-%include "${headerPath}"
-
-#endif
-`;
-    const outputFilePath = `${base.withSlash + output.relative}/${fileName}.i`;
-    fs.writeFileSync(outputFilePath, content);
-
-    compiler.interfaces.push(outputFilePath);
-
-    return outputFilePath;
-}

package/src/functions/finishBuild.js

@@ -1,43 +0,0 @@
-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

@@ -1,106 +0,0 @@
-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

@@ -1,36 +0,0 @@
-/* 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, config, 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(config, a, pathPrefix);
-                obj[key] = value;
-            } else {
-                obj[dKey] = value;
-            }
-        });
-    }
-
-    dependency.dependencies.forEach((dep) => {
-        getRecursiveData(obj, config, dep, field, pathPrefix, platform, subPlatform);
-    });
-}
-
-export default function getData(config, field, pathPrefix, platform = 'Emscripten-x86_64', subPlatform) {
-    const output = {};
-    getRecursiveData(output, config, config, field, pathPrefix, platform, subPlatform);
-
-    return output;
-}

package/src/functions/getLibs.js

@@ -1,33 +0,0 @@
-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)))];
-}

package/src/functions/specs/createBridge.spec.js

@@ -1,51 +0,0 @@
-import { assert } from 'chai';
-import fs from 'fs';
-import p, { dirname } from 'path';
-import * as url from 'node:url';
-import { tmpdir } from 'os';
-import createBridge from './createBridge.js';
-
-const __filename = url.fileURLToPath(import.meta.url);
-const temp = __filename.split('/');
-temp.pop();
-temp.pop();
-const __dirname = temp.join('/');
-
-export function createTempDir(folder) {
-    let path = p.join(tmpdir(), 'cppjs-app-cli-test');
-    if (folder) path = p.join(path, folder);
-
-    if (fs.existsSync(path)) fs.rmSync(path, { recursive: true, force: true });
-    fs.mkdirSync(path, { recursive: true });
-
-    return path;
-}
-
-describe('createBridge', () => {
-    let tempdir;
-    before(async () => {
-        tempdir = createTempDir();
-    });
-
-    it('createBridge', async () => {
-        const path = `${__dirname}/test/data/sample.i`;
-        const bridgeFilePath = createBridge(path, tempdir);
-        const bridgeFileData = fs.readFileSync(bridgeFilePath, 'utf8');
-
-        const startIndex = bridgeFileData.indexOf('#include <emscripten/bind.h>');
-        const bridgeFileDataTrim = bridgeFileData.substring(startIndex, bridgeFileData.length).trim();
-
-        const expectedContent = `#include <emscripten/bind.h>
-
-#include "sample.h"
-
-EMSCRIPTEN_BINDINGS(Sample) {
-  emscripten::class_<Sample>("Sample")
-    .constructor<>()
-    .function("t", &Sample::t)
-  ;
-}
-`.trim();
-        assert.equal(bridgeFileDataTrim, expectedContent);
-    });
-});