cpp.js 0.6.0 → 1.0.0-alpha.2

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2023 Buğra Sarı
+Copyright (c) 2024 Buğra Sarı
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/package.json

@@ -1,15 +1,22 @@
 {
   "name": "cpp.js",
-  "version": "0.6.0",
+  "version": "1.0.0-alpha.2",
   "license": "MIT",
   "type": "module",
+  "homepage": "https://cpp.js.org",
+  "repository": "https://github.com/bugra9/cpp.js.git",
   "bin": {
     "cpp.js": "./src/bin.js"
   },
-  "main": "/src/index.js",
+  "main": "src/index.js",
   "dependencies": {
+    "@rollup/plugin-commonjs": "^26.0.1",
+    "@rollup/plugin-node-resolve": "^15.2.3",
+    "@rollup/plugin-virtual": "^3.0.2",
     "commander": "^9.4.1",
-    "glob": "^8.0.3"
+    "glob": "^8.0.3",
+    "rollup": "^4.18.0",
+    "rollup-plugin-uglify": "^6.0.4"
   },
   "devDependencies": {
     "mocha": "^10.2.0"

package/src/assets/CMakeLists.txt

@@ -1,6 +1,18 @@
 cmake_minimum_required(VERSION 3.25)
+set(CMAKE_CXX_STANDARD 17)
 project("${PROJECT_NAME}")
-set(PACKAGE_HOST "${CMAKE_SYSTEM_NAME}-${CMAKE_HOST_SYSTEM_PROCESSOR}")
+
+if (CMAKE_SYSTEM_NAME STREQUAL "iOS")
+    if (CMAKE_OSX_SYSROOT MATCHES "/iPhoneOS.platform/")
+        set(PACKAGE_HOST "iOS-iphoneos")
+    elseif(CMAKE_OSX_SYSROOT MATCHES "/iPhoneSimulator.platform/")
+        set(PACKAGE_HOST "iOS-iphonesimulator")
+    else()
+        set(PACKAGE_HOST "iOS-unknown")
+    endif()
+else()
+    set(PACKAGE_HOST "${CMAKE_SYSTEM_NAME}-${CMAKE_HOST_SYSTEM_PROCESSOR}")
+endif()
 
 option(BUILD_BRIDGE "Build Bridge" OFF)
 option(BUILD_SOURCE "Build Source" OFF)
@@ -18,24 +30,29 @@ if (BUILD_BRIDGE)
 endif(BUILD_BRIDGE)
 
 set(SRC_FILES "${BUILD_SRC_FILES}" "${BRIDGE_SRC_FILES}")
-add_library("${PROJECT_NAME}" STATIC ${SRC_FILES})
+add_library("${PROJECT_NAME}" "${BUILD_TYPE}" ${SRC_FILES})
+
+set(EXTRA_LINK_LIBRARIES "")
+if(ANDROID)
+    set(EXTRA_LINK_LIBRARIES "log")
+endif()
 
 if (NOT ${CMAKE_SYSTEM_NAME} STREQUAL "")
-    target_link_libraries("${PROJECT_NAME}" "${DEPENDS_CMAKE_NAMES}")
+    target_link_libraries("${PROJECT_NAME}" "${DEPENDS_CMAKE_NAMES}" "${EXTRA_LINK_LIBRARIES}")
 endif()
 
 file(GLOB_RECURSE HEADER_FILES ${HEADER_GLOB})
 target_include_directories("${PROJECT_NAME}" PUBLIC "${HEADER_DIR}")
 
 if (BUILD_SOURCE)
-    target_sources("${PROJECT_NAME}"
-        PUBLIC FILE_SET HEADERS
-        BASE_DIRS "${HEADER_DIR}"
-        FILES "${HEADER_FILES}")
-    string(REPLACE "-" ";" HEADER_FOLDER ${PROJECT_NAME})
-    list(GET HEADER_FOLDER 2 HEADER_FOLDER)
-    install(TARGETS "${PROJECT_NAME}" DESTINATION "prebuilt/${PACKAGE_HOST}/lib")
-    install(TARGETS "${PROJECT_NAME}" FILE_SET HEADERS DESTINATION "prebuilt/${PACKAGE_HOST}/include/cppjs-lib-${HEADER_FOLDER}")
+    install(TARGETS "${PROJECT_NAME}" DESTINATION "lib")
+    if(NOT "${HEADER_FILES}" STREQUAL "")
+        target_sources("${PROJECT_NAME}"
+            PUBLIC FILE_SET HEADERS
+            BASE_DIRS "${HEADER_DIR}"
+            FILES "${HEADER_FILES}")
+        install(TARGETS "${PROJECT_NAME}" FILE_SET HEADERS DESTINATION "include")
+    endif()
 endif(BUILD_SOURCE)
 unset(BUILD_SOURCE CACHE)
 

package/src/assets/browser.js

@@ -0,0 +1,161 @@
+/* eslint-disable import/no-unresolved */
+/* eslint-disable import/first */
+/* eslint-disable no-restricted-syntax */
+/* eslint-disable no-undef */
+import Module from 'cpp.js/module';
+import systemConfig from 'cpp.js/systemConfig';
+
+const VIRTUAL_PATH = '/virtual';
+const AUTO_MOUNTED_PATH = `${VIRTUAL_PATH}/automounted`;
+let cppJsPromise;
+
+function isObject(item) {
+    return (item && typeof item === 'object' && !Array.isArray(item));
+}
+
+function mergeDeep(target, ...sources) {
+    if (!sources.length) return target;
+    const source = sources.shift();
+
+    if (isObject(target) && isObject(source)) {
+        for (const key in source) {
+            if (isObject(source[key])) {
+                if (!target[key]) Object.assign(target, { [key]: {} });
+                mergeDeep(target[key], source[key]);
+            } else {
+                Object.assign(target, { [key]: source[key] });
+            }
+        }
+    }
+
+    return mergeDeep(target, ...sources);
+}
+
+function initCppJs(userConfig = {}) {
+    if (cppJsPromise) return cppJsPromise;
+
+    const config = mergeDeep(systemConfig, userConfig);
+
+    cppJsPromise = new Promise((resolve, reject) => {
+        const m = {
+            print(text) {
+                if (config.logHandler) {
+                    config.logHandler(text, 'stdout');
+                } else {
+                    console.debug(`wasm stdout: ${text}`);
+                }
+            },
+            printErr(text) {
+                if (config.errorHandler) {
+                    config.errorHandler(text, 'stderr');
+                } else {
+                    console.error(`wasm stderr: ${text}`);
+                }
+            },
+            locateFile(fileName) {
+                let path = fileName;
+                if (config.paths && config.paths.wasm && fileName.endsWith('.wasm')) {
+                    path = config.paths.wasm;
+                } else if (config.paths && config.paths.data && (fileName.endsWith('.data.txt') || fileName.endsWith('.data'))) {
+                    path = config.paths.data;
+                }
+
+                let prefix = '';
+                if (config.path) {
+                    prefix = config.path;
+                    if (prefix.slice(-1) !== '/') prefix += '/';
+                }
+
+                let output = prefix + path;
+                if (output.endsWith('.data')) output += '.txt';
+                if (output.substring(0, 4) !== 'http' && output[0] !== '/') output = `/${output}`;
+                return output;
+            },
+
+            preRun: [
+                ({ ENV }) => {
+                    if (ENV && config && config.env) {
+                        Object.entries(config.env).forEach(([key, value]) => {
+                            // eslint-disable-next-line no-param-reassign
+                            ENV[key] = value;
+                        });
+                    }
+                },
+            ],
+            onRuntimeInitialized() {
+                m.FS.mkdir(VIRTUAL_PATH);
+                m.FS.mkdir(AUTO_MOUNTED_PATH);
+                if (config.onRuntimeInitialized) config.onRuntimeInitialized(m);
+            },
+            generateVirtualPath() {
+                const rand = Math.floor(Math.random() * 1000000);
+                const path = `${AUTO_MOUNTED_PATH}/${rand}`;
+                m.FS.mkdir(path);
+                return path;
+            },
+            unmount() {
+                if (typeof importScripts === 'function') {
+                    m.FS.unmount(VIRTUAL_PATH);
+                }
+            },
+            autoMountFiles(files) {
+                return new Promise((resolve2) => {
+                    if (files.length === 0) {
+                        resolve2([]);
+                    } else if (typeof importScripts === 'function') {
+                        const virtualPath = m.generateVirtualPath();
+                        m.FS.mount(m.WORKERFS, { files }, virtualPath);
+                        resolve2(files.map((f) => `${virtualPath}/${f.name}`));
+                    } else {
+                        const promises = [];
+                        [...files].forEach((file) => {
+                            promises.push(file.arrayBuffer());
+                        });
+                        Promise.all(promises).then((buffers) => {
+                            const virtualPath = m.generateVirtualPath();
+                            buffers.forEach((buffer, i) => {
+                                const ss = new Uint8Array(buffer);
+                                m.FS.writeFile(`${virtualPath}/${files[i].name}`, ss);
+                            });
+                            resolve2([...files].map((f) => `${virtualPath}/${f.name}`));
+                        });
+                    }
+                });
+            },
+            getFileBytes(path) {
+                if (!path) return new Uint8Array();
+                return m.FS.readFile(path, { encoding: 'binary' });
+            },
+            getFileList(path = 'virtual') {
+                const contents = path.split('/').reduce((accumulator, currentValue) => accumulator.contents[currentValue], m.FS.root).contents;
+                const fileList = [];
+                Object.keys(contents).forEach((name) => {
+                    const obj = contents[name];
+                    if (obj.usedBytes) fileList.push({ path: `/${path}/${name}`, size: obj.usedBytes });
+                    else if (obj.contents) fileList.push(...m.getFileList(`${path}/${name}`));
+                });
+                return fileList;
+            },
+
+            toArray(vector) {
+                const output = [];
+                for (let i = 0; i < vector.size(); i += 1) {
+                    output.push(vector.get(i));
+                }
+                return output;
+            },
+            toVector(VectorClass, array = []) {
+                const vector = new VectorClass();
+                array.forEach((item) => {
+                    vector.push_back(item);
+                });
+                return vector;
+            },
+        };
+        Module(m).then(resolve).catch(reject);
+    });
+
+    return cppJsPromise;
+}
+
+export default initCppJs;

package/src/assets/dist.cmake

@@ -1,19 +1,44 @@
-cmake_minimum_required(VERSION 3.25)
+cmake_minimum_required(VERSION 3.28)
 set(CMAKE_CXX_STANDARD 11)
 set(PROJECT_NAME "___PROJECT_NAME___")
+set(PROJECT_LIBS "___PROJECT_LIBS___")
 project("${PROJECT_NAME}")
 
-set(PACKAGE_HOST "${CMAKE_SYSTEM_NAME}-${CMAKE_HOST_SYSTEM_PROCESSOR}")
+if(ANDROID)
+    set(PACKAGE_HOST "${CMAKE_SYSTEM_NAME}-${CMAKE_ANDROID_ARCH_ABI}")
+    set(PACKAGE_DIR "${PROJECT_SOURCE_DIR}/${PACKAGE_HOST}/lib")
+elseif(APPLE)
+    if (CMAKE_SYSTEM_NAME STREQUAL "iOS")
+        set(PACKAGE_DIR "${PROJECT_SOURCE_DIR}")
+    else()
+        set(PACKAGE_HOST "${CMAKE_SYSTEM_NAME}-${CMAKE_HOST_SYSTEM_PROCESSOR}")
+        set(PACKAGE_DIR "${PROJECT_SOURCE_DIR}/${PACKAGE_HOST}/lib")
+    endif()
+elseif(UNIX)
+    set(PACKAGE_HOST "${CMAKE_SYSTEM_NAME}-${CMAKE_HOST_SYSTEM_PROCESSOR}")
+    set(PACKAGE_DIR "${PROJECT_SOURCE_DIR}/${PACKAGE_HOST}/lib")
+else()
+    set(PACKAGE_HOST "${CMAKE_SYSTEM_NAME}-${CMAKE_HOST_SYSTEM_PROCESSOR}")
+    set(PACKAGE_DIR "${PROJECT_SOURCE_DIR}/${PACKAGE_HOST}/lib")
+endif()
 
-find_library(PROJECT_LIBRARY
-    NAMES "${PROJECT_NAME}"
-    PATHS "${PROJECT_SOURCE_DIR}/${PACKAGE_HOST}/lib"
-    NO_CACHE
-    NO_DEFAULT_PATH
-    NO_CMAKE_FIND_ROOT_PATH
-    REQUIRED
-)
+set(PROJECT_LIBS_DIR)
+foreach(L IN LISTS PROJECT_LIBS)
+    SET(FOUND_LIB "FOUND_LIB-NOTFOUND")
+    find_library(FOUND_LIB
+        NAMES "${L}"
+        PATHS "${PACKAGE_DIR}"
+        NO_CACHE
+        NO_DEFAULT_PATH
+        NO_CMAKE_FIND_ROOT_PATH
+        REQUIRED
+    )
+    LIST(APPEND PROJECT_LIBS_DIR ${FOUND_LIB})
+endforeach()
 
 add_library("${PROJECT_NAME}" INTERFACE)
-target_link_libraries("${PROJECT_NAME}" INTERFACE "${PROJECT_LIBRARY}")
+target_link_libraries("${PROJECT_NAME}" INTERFACE "${PROJECT_LIBS_DIR}")
+
+if(NOT APPLE)
 target_include_directories("${PROJECT_NAME}" INTERFACE "${PROJECT_SOURCE_DIR}/${PACKAGE_HOST}/include")
+endif()