cpp.js 0.5.0 → 0.6.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cpp.js",
-  "version": "0.5.0",
+  "version": "0.6.1",
   "license": "MIT",
   "type": "module",
   "bin": {

package/src/assets/CMakeLists.txt

@@ -1,37 +1,46 @@
 cmake_minimum_required(VERSION 3.25)
+set(CMAKE_CXX_STANDARD 17)
 project("${PROJECT_NAME}")
+set(PACKAGE_HOST "${CMAKE_SYSTEM_NAME}-${CMAKE_HOST_SYSTEM_PROCESSOR}")
 
 option(BUILD_BRIDGE "Build Bridge" OFF)
 option(BUILD_SOURCE "Build Source" OFF)
 
-if(BUILD_SOURCE)
-file(GLOB_RECURSE BUILD_SRC_FILES ${NATIVE_GLOB})
+foreach(depend IN ZIP_LISTS DEPENDS_CMAKE_PATHS DEPENDS_CMAKE_NAMES)
+    add_subdirectory("${depend_0}" "${CMAKE_CURRENT_BINARY_DIR}/dependencies/${depend_1}")
+endforeach()
+
+if (BUILD_SOURCE)
+    file(GLOB_RECURSE BUILD_SRC_FILES ${NATIVE_GLOB})
 endif(BUILD_SOURCE)
 
-if(BUILD_BRIDGE)
-file(GLOB BRIDGE_SRC_FILES "${BRIDGE_DIR}/*.i.cpp")
+if (BUILD_BRIDGE)
+    file(GLOB BRIDGE_SRC_FILES "${BRIDGE_DIR}/*.i.cpp")
 endif(BUILD_BRIDGE)
 
 set(SRC_FILES "${BUILD_SRC_FILES}" "${BRIDGE_SRC_FILES}")
-add_library("${PROJECT_NAME}" STATIC ${SRC_FILES})
-
-file(GLOB LIB_HEADERS_DIR "${BASE_DIR}/node_modules/cppjs-lib-*/include" "${BASE_DIR}/node_modules/cppjs-lib-*/node_modules/cppjs-lib-*/include")
-file(GLOB_RECURSE HEADER_FILES ${HEADER_GLOB})
-target_include_directories("${PROJECT_NAME}" PUBLIC "${LIB_HEADERS_DIR}" "${HEADER_DIR}")
+add_library("${PROJECT_NAME}" "${BUILD_TYPE}" ${SRC_FILES})
 
-if(BUILD_SOURCE)
-target_sources("${PROJECT_NAME}"
-    PUBLIC FILE_SET HEADERS
-    BASE_DIRS "${HEADER_DIR}"
-    FILES "${HEADER_FILES}")
+if (NOT ${CMAKE_SYSTEM_NAME} STREQUAL "")
+    target_link_libraries("${PROJECT_NAME}" "${DEPENDS_CMAKE_NAMES}")
+endif()
 
-string(REPLACE "-" ";" HEADER_FOLDER ${PROJECT_NAME})
-list(GET HEADER_FOLDER 2 HEADER_FOLDER)
-install(TARGETS "${PROJECT_NAME}" FILE_SET HEADERS DESTINATION "include/cppjs-lib-${HEADER_FOLDER}")
+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}")
 endif(BUILD_SOURCE)
 unset(BUILD_SOURCE CACHE)
 
-if(BUILD_BRIDGE)
-install(TARGETS "${PROJECT_NAME}")
+if (BUILD_BRIDGE)
+    install(TARGETS "${PROJECT_NAME}")
 endif(BUILD_BRIDGE)
 unset(BUILD_BRIDGE CACHE)

package/src/assets/dist.cmake

@@ -0,0 +1,19 @@
+cmake_minimum_required(VERSION 3.25)
+set(CMAKE_CXX_STANDARD 11)
+set(PROJECT_NAME "___PROJECT_NAME___")
+project("${PROJECT_NAME}")
+
+set(PACKAGE_HOST "${CMAKE_SYSTEM_NAME}-${CMAKE_HOST_SYSTEM_PROCESSOR}")
+
+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
+)
+
+add_library("${PROJECT_NAME}" INTERFACE)
+target_link_libraries("${PROJECT_NAME}" INTERFACE "${PROJECT_LIBRARY}")
+target_include_directories("${PROJECT_NAME}" INTERFACE "${PROJECT_SOURCE_DIR}/${PACKAGE_HOST}/include")

package/src/bin.js

@@ -55,11 +55,14 @@ function generateLib(platform, output, base) {
 
     compiler.createBridge();
     compiler.createWasm({ cc: ['-O3'] });
-    createDir('lib', compiler.config.paths.output);
+    createDir('prebuilt', compiler.config.paths.output);
     fs.copyFileSync(`${compiler.config.paths.temp}/${compiler.config.general.name}.js`, `${compiler.config.paths.output}/${compiler.config.general.name}.js`);
     fs.copyFileSync(`${compiler.config.paths.temp}/${compiler.config.general.name}.wasm`, `${compiler.config.paths.output}/${compiler.config.general.name}.wasm`);
-    fs.copyFileSync(`${compiler.config.paths.temp}/lib${compiler.config.general.name}.a`, `${compiler.config.paths.output}/lib/lib${compiler.config.general.name}.a`);
-    fs.rmSync(`${compiler.config.paths.output}/include`, { recursive: true, force: true });
-    fs.renameSync(`${compiler.config.paths.temp}/include`, `${compiler.config.paths.output}/include`);
+    fs.rmSync(`${compiler.config.paths.output}/prebuilt`, { recursive: true, force: true });
+    fs.renameSync(`${compiler.config.paths.temp}/prebuilt`, `${compiler.config.paths.output}/prebuilt`);
+
+    const distCmakeContent = fs.readFileSync(`${compiler.config.paths.cli}/assets/dist.cmake`, { encoding: 'utf8', flag: 'r' })
+        .replace('___PROJECT_NAME___', compiler.config.general.name);
+    fs.writeFileSync(`${compiler.config.paths.output}/prebuilt/CMakeLists.txt`, distCmakeContent);
     fs.rmSync(compiler.config.paths.temp, { recursive: true, force: true });
 }

package/src/functions/createWasm.js

@@ -4,63 +4,165 @@ import pullDockerImage, { getDockerImage } from '../utils/pullDockerImage.js';
 import getBaseInfo from '../utils/getBaseInfo.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.compile();
+    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]);
+        }
+    }
+
+    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 '';
     }
 
-    compile() {
+    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`,
-            ...glob.sync("node_modules/cppjs-lib-*-wasm/lib/lib*.a", { absolute: true, cwd: this.config.paths.project }),
-            ...glob.sync("node_modules/cppjs-lib-*-wasm/node_modules/cppjs-lib-*-wasm/lib/lib*.a", { absolute: true, cwd: this.config.paths.project }),
-        ].filter(path => !!path.toString()).map(path => `/live/${getPathInfo(path, this.config.paths.base).relative}`);
+            ...dependLibs,
+        ].filter(path => !!path.toString()).map(path => this.getPath(path));
 
         this.cc();
 
         return this.config.paths.temp;
     }
 
-    cmake(name, isBuildSource, isBuildBridge) {
+    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(';');
+    }
+
+    getCmakeParams(name, isBuildSource, isBuildBridge) {
         const params = [];
         if (isBuildSource) params.push('-DBUILD_SOURCE=TRUE');
         if (isBuildBridge) params.push('-DBUILD_BRIDGE=TRUE');
 
-        const output = getPathInfo(this.config.paths.temp, this.config.paths.base);
-        const projectPath = getPathInfo(process.cwd(), this.config.paths.base);
-        const native = this.config.paths.native.map(p => `/live/${getPathInfo(p, this.config.paths.base).relative}`).join(';');
-        const header = this.config.paths.header.map(p => `/live/${getPathInfo(p, this.config.paths.base).relative}`).join(';');
+        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);
 
-        let cMakeParentPath = this.config.paths.cmake.split('/');
-        cMakeParentPath.pop();
-        cMakeParentPath = cMakeParentPath.join('/');
+        const cMakeParentPath = getParentPath(this.config.paths.cmake);
+
         const args = [
-            "run", "--user", getOsUserAndGroupId(), "-v", `${base.withoutSlash}:/live`, "-v", `${cMakeParentPath}:/cmake`, "--workdir", `/live/${output.relative}`, getDockerImage(),
-            "emcmake", "cmake", "/cmake", '-DCMAKE_BUILD_TYPE=Release',
-            `-DBASE_DIR=/live/${projectPath.relative}`,
-            `-DNATIVE_GLOB=${this.config.ext.source.map(ext => `${native}/*.${ext}`).join(';')}`,
-            `-DHEADER_GLOB=${this.config.ext.header.map(ext => `${header}/*.${ext}`).join(';')}`,
-            `-DHEADER_DIR=${header}`,
-            `-DCMAKE_INSTALL_PREFIX=/live/${output.relative}`, `-DBRIDGE_DIR=/live/${output.relative}/bridge`, `-DPROJECT_NAME=${name}`, ...params,
+            "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);
@@ -68,14 +170,14 @@ class CppjsCompiler {
     }
 
     make() {
-        const output = getPathInfo(this.config.paths.temp, this.config.paths.base);
+        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", `/live/${output.relative}`, getDockerImage(),
+            "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' };
@@ -84,12 +186,11 @@ class CppjsCompiler {
     }
 
     cc() {
-        const input = getPathInfo(this.config.paths.temp, this.config.paths.base);
-        const output = getPathInfo(this.config.paths.temp, this.config.paths.base);
+        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', `/live/${output.relative}/${this.config.general.name}.js`, '--extern-post-js', '/cli/assets/extern-post.js'
+            "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);

package/src/index.js

@@ -1,11 +1,11 @@
 import createBridge from './functions/createBridge.js';
 import findOrCreateInterfaceFile from './functions/findOrCreateInterfaceFile.js';
-import createWasm from './functions/createWasm.js';
+import createWasm, { getCmakeParams } from './functions/createWasm.js';
 import getConfig from './utils/getConfig.js';
 
 export default class CppjsCompiler {
-    constructor(param) {
-        this.config = getConfig(param);
+    constructor() {
+        this.config = getConfig();
         this.interfaces = [];
     }
 
@@ -20,4 +20,8 @@ export default class CppjsCompiler {
     createWasm(options) {
         return createWasm(this, options);
     }
+
+    getCmakeParams() {
+        return getCmakeParams(this);
+    }
 }

package/src/utils/createTempDir.js

@@ -2,7 +2,7 @@ import fs from 'fs';
 import p from 'path';
 
 export default function createTempDir(folder = 'a'+Math.random(), base = process.cwd()) {
-    const path = p.join(base, 'node_modules', ".cppjs");
+    const path = p.join(base, ".cppjs");
     return createDir(folder, path);
 }
 

package/src/utils/findCMakeListsFile.js

@@ -8,5 +8,9 @@ export default function findCMakeListsFile(basePath = process.cwd()) {
     }
 
     if (temp.length > 0) return temp[0];
+    return getCliCMakeListsFile();
+}
+
+export function getCliCMakeListsFile() {
     return getCliPath() + '/assets/CMakeLists.txt';
 }

package/src/utils/getConfig.js

@@ -3,16 +3,15 @@ import createTempDir, { createDir } from './createTempDir.js';
 import findCMakeListsFile from './findCMakeListsFile.js';
 import p from 'path';
 import * as url from 'node:url';
-import { createRequire } from 'module';
 
 const __filename = url.fileURLToPath(import.meta.url);
 const temp = __filename.split('/'); temp.pop(); temp.pop();
 const __dirname = temp.join('/');
-const require = createRequire(import.meta.url);
 
 /**
  * @typedef {Object} Config
  * @property {string} general General
+ * @property {any[]} dependencies Dependencies
  * @property {ConfigPaths} paths Paths
  * @property {ConfigExtensions} ext Extensions
  */
@@ -42,44 +41,37 @@ const require = createRequire(import.meta.url);
  * @property {string} name Project name
  */
 
-export default function getConfig(param) {
-    let tempConfig = { general: {}, paths: {}, ext: {} };
+let tempConfig = { general: {}, dependencies: [], paths: {}, ext: {}, export: {} };
+await initDefaultConfigFile();
 
-    if (!param || (typeof param === 'string' || param instanceof String)) {
-        const ext = (param || '').split('.').at(-1)
-        let filePath;
+async function initDefaultConfigFile() {
+    let filePath;
+    ['json', 'js', 'mjs', 'cjs', 'ts'].some(e => {
+        filePath = `${process.cwd()}/cppjs.config.${e}`;
+        if (!fs.existsSync(filePath)) filePath = null;
+        else return true;
+    });
 
-        if (param && ['json', 'js', 'mjs', 'cjs', 'ts'].includes(ext)) {
-            filePath = `${process.cwd()}/${param}`;
-            if (!fs.existsSync(filePath)) filePath = null;
-        } else {
-            filePath = `${process.cwd()}/.cppjs.config.json`;
-            if (!fs.existsSync(filePath)) filePath = null;
+    if (filePath) {
+        let file = await import(filePath);
+        if (file.default) file = file.default;
 
-            /* filePath = `${process.cwd()}/.cpp.config.js`;
-            if (!fs.existsSync(filePath)) filePath = null; */
-        }
-
-        if (filePath) {
-            const file = require(filePath);
-            if (file.default) file = file.default;
-            if (typeof file === 'function') tempConfig = file();
-            else if (typeof file === "object") tempConfig = file;
-        }
-    } else if (typeof param === "object") {
-        tempConfig = param;
-    } else {
-        console.error('Error');
+        if (typeof file === 'function') tempConfig = file();
+        else if (typeof file === "object") tempConfig = file;
     }
+}
 
+export default function getConfig() {
     return fillConfig(forceToConfigSchema(tempConfig));
 }
 
 function forceToConfigSchema(tempConfig) {
     const config = {
         general: tempConfig && tempConfig.general ? tempConfig.general : {},
+        dependencies: tempConfig && tempConfig.dependencies ? tempConfig.dependencies : [],
         paths: tempConfig && tempConfig.paths ? tempConfig.paths : {},
         ext: tempConfig && tempConfig.ext ? tempConfig.ext : {},
+        export: tempConfig && tempConfig.export ? tempConfig.export : {},
     };
     return config;
 }
@@ -97,13 +89,15 @@ function getAbsolutePath(projectPath, path) {
     return p.resolve(path);
 }
 
-function fillConfig(tempConfig) {
+function fillConfig(tempConfig, options = {}) {
     const config = {
         general: {},
+        dependencies: tempConfig.dependencies ? tempConfig.dependencies.map(d => fillConfig(forceToConfigSchema(d), { depend: true })) : [],
         paths: {
             project: getAbsolutePath(null, tempConfig.paths.project) || process.cwd(),
         },
         ext: {},
+        export: {},
     };
 
     if (!config.general.name) {
@@ -126,13 +120,18 @@ function fillConfig(tempConfig) {
     config.paths.header = (tempConfig.paths.header || config.paths.native).map(p => getPath(p));
     config.paths.bridge = (tempConfig.paths.bridge || [...config.paths.native, config.paths.temp]).map(p => getPath(p));
     config.paths.output = getPath(tempConfig.paths.output) || config.paths.temp;
-    config.paths.cmake = getPath(tempConfig.paths.cmake || findCMakeListsFile(config.paths.project));
+    config.paths.cmake = options.depend ? findCMakeListsFile(config.paths.output) : getPath(tempConfig.paths.cmake || findCMakeListsFile(config.paths.project));
     config.paths.cli = __dirname;
 
     config.ext.header = tempConfig.ext.header || ['h', 'hpp', 'hxx', 'hh'];
     config.ext.source = tempConfig.ext.source || ['c', 'cpp', 'cxx', 'cc'];
     config.ext.module = tempConfig.ext.module || ['i'];
 
+    config.export.type = tempConfig.export.type || 'cmake';
+    config.export.header = tempConfig.export.header || 'include';
+    config.export.libPath = getPath(tempConfig.export.libPath || 'lib');
+    config.export.libName = tempConfig.export.libName || [`lib${config.general.name}.a`];
+
     createDir('interface', config.paths.temp);
     createDir('bridge', config.paths.temp);
 

package/src/utils/getDirName.js

@@ -0,0 +1,7 @@
+import * as url from 'node:url';
+
+export default function getDirName(importUrl) {
+    const __filename = url.fileURLToPath(importUrl);
+    const temp = __filename.split('/'); temp.pop();
+    return temp.join('/');
+}