@xrystal/core 3.3.7 → 3.4.3

package/bin/main-cli.js

@@ -1,179 +1,98 @@
 #!/usr/bin/env node
-import { execSync } from 'child_process'
-import fs from 'fs'
-import path from 'path'
-import yaml from 'yaml'
-import { Command } from 'commander'
-import chalk from 'chalk'
-import ora from 'ora'
 
-import { defaultOwnerTmpFilePath, defaultTmpFilePath, packageName, templateRepoUri, tmpFileDefaultExt, tmpFileDefaultMainFolderName, tmpFileDefaultName } from './constants/index.mjs'
-import { findFileRecursively, resolveObjWithHandlebars } from './helpers/index.mjs'
-
-let cli = null
-
-let ownerTmpFilePath = null
-let ownerTmpFile = null
-
-let parsedTmpObject = null
-let resolvedTmpObject = null
-
-let projectMainFolderPath = null
-
-try {
-  cli = new Command()
+import { execSync } from "node:child_process"
+import fs from "node:fs"
+import path from "node:path"
+import { Command } from "commander"
+import chalk from "chalk"
+import ora from "ora"
+import yaml from "yaml"
+
+import {
+  defaultOwnerTmpFilePath,
+  defaultTmpFilePath,
+  packageName,
+  templateRepoUri,
+  tmpFileDefaultExt,
+  tmpFileDefaultMainFolderName,
+  tmpFileDefaultName
+} from "./constants/index.mjs"
+import { findFileRecursively, resolveObjWithHandlebars } from "./helpers/index.mjs"
+
+const isBun = typeof Bun !== "undefined"
+const packageManager = isBun ? "bun" : "npm"
+
+const setupCLI = async () => {
+  const cli = new Command()
+
+  let ownerTmpFilePath = findFileRecursively(".", tmpFileDefaultName, tmpFileDefaultExt)
 
   try {
-    ownerTmpFilePath = findFileRecursively('.', tmpFileDefaultName, tmpFileDefaultExt)
-
-    if(!ownerTmpFilePath){
+    if (!ownerTmpFilePath) {
       const tmpFilePathBuffer = fs.readFileSync(defaultTmpFilePath)
-
-      fs.mkdirSync(path.resolve(tmpFileDefaultMainFolderName), {recursive:true})
-
+      fs.mkdirSync(path.resolve(tmpFileDefaultMainFolderName), { recursive: true })
       fs.writeFileSync(defaultOwnerTmpFilePath, tmpFilePathBuffer)
-
       ownerTmpFilePath = defaultOwnerTmpFilePath
     }
 
-    ownerTmpFile = fs.readFileSync(ownerTmpFilePath)
+    const ownerTmpFile = fs.readFileSync(ownerTmpFilePath, "utf8")
+    const parsedTmpObject = yaml.parse(ownerTmpFile)
+    const resolvedTmpObject = resolveObjWithHandlebars(parsedTmpObject, parsedTmpObject)
+    const projectMainFolderPath = path.resolve(resolvedTmpObject.configs.mainFolderPath)
 
-    if(!ownerTmpFile){
-        throw new Error(`${tmpFileDefaultName} File not read.`)
+    if (!fs.existsSync(projectMainFolderPath)) {
+      fs.mkdirSync(projectMainFolderPath, { recursive: true })
     }
 
-    parsedTmpObject = yaml.parse(ownerTmpFile.toString())
-
-    resolvedTmpObject = resolveObjWithHandlebars(parsedTmpObject, parsedTmpObject)
-
-    projectMainFolderPath = path.resolve(resolvedTmpObject.configs.mainFolderPath)
-
-    if(!fs.existsSync(path.resolve(projectMainFolderPath))){
-      fs.mkdirSync(path.resolve(projectMainFolderPath))
-    }
-
-  } catch (error) {
-    console.error(`${packageName} Error:`, error?.message)
-  }
-
-  cli
-  .command('webpack')
-  .action(function (pathOption, options) {
-    if(resolvedTmpFile.configs.worker === 'development'){
-      exec(
-        `node --loader ts-node/esm node_modules/tmp-project-tool/node_modules/webpack-dev-server/bin/webpack-dev-server --config ${
-          path.resolve(resolvedTmpFile.configs.webpack.location.worker[resolvedTmpFile.configs.worker])
-        }`, {cwd: path.resolve()}, (error, stdout, stderr) => {
-
-        if (error) {
-          console.error(`error: ${error.message}`)
-          return
-        }
-
-        if (stderr) {
-          console.error(`stderr: ${stderr}`)
-          return
-        }
-
-        console.log(`stdout: ${stdout}`)
-      })
-    }else{
-      exec(
-        `node --loader ts-node/esm node_modules/tmp-project-tool/node_modules/webpack-cli/bin/cli.js --config ${
-          path.resolve(resolvedTmpFile.configs.webpack.location.worker[resolvedTmpFile.configs.worker])
-        }`, {cwd: path.resolve()}, (error, stdout, stderr) => {
-
-        if (error) {
-          console.error(error, stderr)
-          return
-        }
+    cli
+      .command("create <project-name>")
+      .description("Clone template from GitHub (Private/Public)")
+      .action(async (projectName) => {
+        const targetPath = path.join(process.cwd(), projectName)
 
-        if (stderr) {
-          console.error(`stderr: ${stderr}`)
-          return
+        if (fs.existsSync(targetPath)) {
+          console.log(chalk.red(`❌ Error: '${projectName}' folder already exists!`))
+          process.exit(1)
         }
 
-        console.log(`stdout: ${stdout}`)
-      })
-    }
-  })
-
-  /*
-    exec(`node --loader ts-node/esm ./${packagePathname}/src/index.ts ${options.config ? `--config ${options.config}` : ''}` , (error, stdout, stderr) => {
-      if (error) {
-        console.error(`error: ${error.message}`)
-        return
-      }
-
-      if (stderr) {
-        console.error(`stderr: ${stderr}`)
-        return
-      }
-
-      console.log(`stdout: ${stdout}`)
-    })
-  */
-
-  cli
-  .command('create <project-name>')
-  .description('Clone template from GitHub (Private/Public)')
-  .action(async (projectName) => {
-    const targetPath = path.join(process.cwd(), projectName)
-
-    // 1. Klasör Kontrolü
-    if (fs.existsSync(targetPath)) {
-      console.log(chalk.red(`❌ Error: '${projectName}' folder already exists!`))
-      process.exit(1)
-    }
-
-    const repoURL = templateRepoUri
+        const spinner = ora("Cloning template from GitHub...").start()
 
-    const spinner = ora('Cloning template from GitHub...').start()
+        try {
+          execSync(`git clone --depth 1 ${templateRepoUri} "${targetPath}"`, { stdio: "ignore" })
 
-    try {
-      execSync(`git clone --depth 1 ${repoURL} "${targetPath}"`, {
-        stdio: 'ignore'
-      })
+          const gitFolder = path.join(targetPath, ".git")
+          if (fs.existsSync(gitFolder)) {
+            fs.rmSync(gitFolder, { recursive: true, force: true })
+          }
 
-      const gitFolder = path.join(targetPath, '.git')
-      if (fs.existsSync(gitFolder)) {
-        fs.rmSync(gitFolder, { recursive: true, force: true })
-      }
+          spinner.succeed(chalk.green("Template cloned successfully!"))
+          console.log(chalk.blue(`\n📦 Dependencies loading with ${packageManager}... (${projectName})`))
 
-      spinner.succeed(chalk.green('Template cloned successfully!'))
+          const installCmd = isBun ? "bun install" : "npm install"
+          execSync(installCmd, { cwd: targetPath, stdio: "inherit" })
 
-      console.log(chalk.blue(`\n📦 Dependencies loading... (${projectName})`))
+          console.log(chalk.green("\n✅ Project Ready!"))
+          console.log(chalk.white(`\nStart Project:\n`))
+          console.log(chalk.cyan(`   cd ${projectName}`))
+          console.log(chalk.cyan(`   ${packageManager} run dev`))
 
-      execSync('npm install', {
-        cwd: targetPath,
-        stdio: 'inherit'
+        } catch (err) {
+          spinner.fail(chalk.red("Failed to clone or install!"))
+          console.error(chalk.red(`\nError details: ${err.message}`))
+          if (fs.existsSync(targetPath)) fs.rmSync(targetPath, { recursive: true, force: true })
+        }
       })
 
-      console.log(chalk.green('\n✅ Project Ready!'))
-      console.log(chalk.white(`\nStart Project:\n`))
-      console.log(chalk.cyan(`   cd ${projectName}`))
-      console.log(chalk.cyan(`   npm run dev`))
-
-    } catch (err) {
-      spinner.fail(chalk.red('Failed to clone or install!'))
+    cli.parse(process.argv)
 
-      console.error(chalk.red('\nPossible reasons:'))
-      console.error(chalk.yellow('1. You might not have access to this private repo.'))
-      console.error(chalk.yellow('2. Git is not installed or configured on this machine.'))
-      console.error(chalk.red(`\nError details: ${err.message}`))
-
-      if (fs.existsSync(targetPath)) {
-        fs.rmSync(targetPath, { recursive: true, force: true })
-      }
-    }
-  })
-
-  cli.parse(process.argv)
-} catch (error) {
-  console.error(`x cli:${error?.message}`)
+  } catch (error) {
+    console.error(`${packageName} Initialization Error:`, error?.message)
+  }
 }
 
-process.on('uncaughtException', (error) => {
-  console.error('Uncaught Exception:', error.message)
+process.on("uncaughtException", (error) => {
+  console.error("Critical Error:", error.message)
   process.exit(1)
-})
+})
+
+setupCLI()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xrystal/core",
-  "version": "3.3.7",
+  "version": "3.4.3",
   "description": "Project core for xrystal",
   "publishConfig": {
     "access": "public",
@@ -21,19 +21,7 @@
   "exports": {
     ".": {
       "types": "./source/index.d.ts",
-      "import": "./source/index.js"
-    },
-    "./source/*/index": {
-      "types": "./source/*/index.d.ts",
-      "import": "./source/*/index.js"
-    },
-    "./source/*": {
-      "types": "./source/*/index.d.ts",
-      "import": "./source/*/index.js"
-    },
-    "./source/*.js": {
-      "types": "./source/*.d.ts",
-      "import": "./source/*.js"
+      "default": "./source/index.js"
     }
   },
   "type": "module",
@@ -41,80 +29,47 @@
     "tmp": "./bin/main-cli.js"
   },
   "scripts": {
-    "dev": "tsx watch --env-file=../infrastructer/x/environments/.global.env --env-file=../infrastructer/x/environments/.dev.env --include \"./source/**/*.ts\" --include \"./x\" --exclude node_modules --exclude x/ts-build source/index.ts",
-    "lint": "eslint .",
-    "build": "./node_modules/.bin/tsc",
-    "start": "tsx --env-file=../infrastructer/x/environments/.global.env --env-file=../infrastructer/x/environments/.dev.env --include \"./source/**/*.ts\" --include \"./x\" --exclude node_modules --exclude x/ts-build source/index.ts",
-    "webpack-dev": "node --loader ts-node/esm node_modules/webpack-dev-server/bin/webpack-dev-server --config ./x/webpack/webpack.config.dev.ts",
-    "webpack-prod": "node --loader ts-node/esm node_modules/webpack-cli/bin/cli.js --config ./x/webpack/webpack.config.prod.ts"
+    "dev": "bun --watch --env-file=../infrastructer/x/environments/.global.env --env-file=../infrastructer/x/environments/.dev.env source/index.ts",
+    "build": "rm -rf x/dist && bun build ./source/*.ts ./source/**/*.ts --outdir ./x/dist --target node --external '*' && bunx tsc --project tsconfig.json",
+    "build:dev": "bun --watch --env-file=../infrastructer/x/environments/.global.env --env-file=../infrastructer/x/environments/.dev.env ./x/dist/index.js",
+    "build:prod": "bun run build && find source -name '*.ts' -delete && cp -r x/dist/* source/ && rm -rf x/dist",
+    "start": "bun --env-file=../infrastructer/x/environments/.global.env --env-file=../infrastructer/x/environments/.dev.env source/index.js"
   },
   "dependencies": {
-    "@babel/cli": "^7.21.0",
-    "@babel/core": "^7.21.4",
-    "@babel/preset-env": "^7.21.4",
-    "@babel/preset-react": "^7.18.6",
     "@types/bcrypt": "^5.0.2",
-    "@types/webpack": "^5.28.3",
-    "@types/webpack-dev-server": "^4.7.2",
-    "@types/webpack-merge": "^5.0.0",
-    "@types/webpack-node-externals": "^3.0.4",
     "@types/yaml": "^1.9.7",
     "axios": "^1.13.2",
-    "babel-loader": "^9.1.2",
     "chalk": "^5.6.2",
-    "clean-webpack-plugin": "^4.0.0",
     "commander": "^13.0.0",
-    "copy-webpack-plugin": "^11.0.0",
-    "css-loader": "^6.7.3",
-    "dotenv": "^16.3.1",
     "ejs": "^3.1.9",
-    "ejs-compiled-loader": "^3.1.0",
-    "ejs-loader": "^0.5.0",
-    "ejs-webpack-loader": "^2.2.2",
-    "file-loader": "^6.2.0",
     "handlebars": "^4.7.8",
-    "handlebars-loader": "^1.7.3",
-    "html-loader": "^4.2.0",
-    "html-webpack-plugin": "^5.6.0",
     "i18next": "^25.6.3",
     "i18next-fs-backend": "^2.6.1",
     "i18next-http-middleware": "^3.8.2",
     "jquery": "^3.7.1",
     "kafkajs": "^2.2.4",
     "logform": "^2.7.0",
-    "mini-css-extract-plugin": "^2.9.0",
     "minimist": "^1.2.8",
     "moment-timezone": "^0.6.0",
     "nodemailer": "^7.0.11",
     "nodemailer-express-handlebars": "^7.0.0",
     "ora": "^9.0.0",
-    "postcss-loader": "^7.2.4",
+    "qs": "^6.14.1",
     "react": "^18.2.0",
     "react-dom": "^18.2.0",
     "sass": "^1.62.0",
-    "sass-loader": "^13.2.2",
     "soap": "^1.6.0",
-    "ts-loader": "^8.0.0",
-    "url-loader": "^4.1.1",
-    "webpack-dev-server": "^4.13.3",
-    "webpack-merge": "^6.0.1",
-    "webpack-node-externals": "^3.0.0",
     "winston": "^3.19.0",
     "winston-daily-rotate-file": "^5.0.0",
     "winston-mongodb": "^7.0.1",
     "yaml": "^2.5.0"
   },
-  "author": "y.yasir.k",
-  "license": "ISC",
   "devDependencies": {
+    "@types/express": "^5.0.6",
     "@types/minimist": "^1.2.5",
+    "@types/node": "^25.0.6",
     "@types/nodemailer": "^7.0.4",
     "@types/nodemailer-express-handlebars": "^4.0.6",
-    "ts-node": "^10.9.2",
-    "tsconfig-paths": "^4.2.0",
-    "tsx": "^4.21.0",
-    "typescript": "^5.5.3",
-    "webpack": "^5.104.1",
-    "webpack-cli": "^6.0.1"
+    "typescript": "^5.5.3"
   }
 }

package/source/project/index.d.ts

@@ -1,7 +1,6 @@
-import webpack from 'webpack';
-import * as webpackMerge from 'webpack-merge';
-import nodeExternals from 'webpack-node-externals';
-import MiniCssExtractPlugin from 'mini-css-extract-plugin';
-declare const coreLoader: any;
-export { webpack, webpackMerge, nodeExternals, MiniCssExtractPlugin };
+declare const coreLoader: () => Promise<{
+    _?: undefined;
+} | {
+    _: any;
+}>;
 export default coreLoader;

package/source/project/index.js

@@ -1,94 +1,63 @@
 // => import dependencies
 import path from 'path';
-import webpack from 'webpack';
-import * as webpackMerge from 'webpack-merge';
-import nodeExternals from 'webpack-node-externals';
-import MiniCssExtractPlugin from 'mini-css-extract-plugin';
 import { SystemService, ConfigsService, LoggerService, EventsService, LocalizationsService } from '../loader/index';
 import { packageName, tmpFileDefaultName, tmpFileDefaultExt, findFileRecursively, TmpFileLoader, x, kafkaBrokers, systemLoggerLayer, } from '../utils/index';
 //
 let coreHasRun = false;
 const coreLoader = async () => {
-    let response = {};
-    let r = {};
-    let rootFolderPath = '';
-    let ownerTmpFilePath = null;
-    let resolvedTmpFileJson = null;
-    if (coreHasRun) {
-        return response;
-    }
+    if (coreHasRun)
+        return {};
     try {
-        ownerTmpFilePath = findFileRecursively('.', tmpFileDefaultName, tmpFileDefaultExt);
+        const ownerTmpFilePath = findFileRecursively(".", tmpFileDefaultName, tmpFileDefaultExt);
         if (!ownerTmpFilePath) {
-            console.error(`${tmpFileDefaultName} file not found.`);
+            throw new Error(`${tmpFileDefaultName} file not found`);
         }
-        const tmpFileObject = new TmpFileLoader({
-            filePath: ownerTmpFilePath
+        const tmpFileObject = new TmpFileLoader({ filePath: ownerTmpFilePath });
+        const r = tmpFileObject.getResolvedTmpFile();
+        const { configs } = r;
+        const rootFolderPath = configs.rootFolderPath;
+        const services = [
+            SystemService,
+            ConfigsService,
+            LoggerService,
+            EventsService,
+            LocalizationsService
+        ];
+        services.forEach(service => x.set({ service, reference: service }));
+        const system = x.get(SystemService);
+        const configService = x.get(ConfigsService);
+        const logger = x.get(LoggerService);
+        const events = x.get(EventsService);
+        const i18n = x.get(LocalizationsService);
+        await system.load({
+            tmp: { _: r }
+        });
+        await configService.load({
+            tmpFolderPath: rootFolderPath,
+            systemService: system,
+            envLoadPath: path.join(rootFolderPath, configs.loaders.configs.envLoadPath),
+            ...(configs.loaders.configs.globalEnvFileName && { globalEnvFileName: configs.loaders.configs.globalEnvFileName })
+        });
+        await logger.load({
+            loadPath: path.join(rootFolderPath, configs.loaders.loggers.loadPath),
+            loggerLevel: systemLoggerLayer ?? configs.loaders.loggers.logLevel,
+            serviceName: configs.service,
+            env: process.env.NODE_ENV,
+            kafkaBrokers: kafkaBrokers ?? "",
+            kafkaTopic: configs.loaders.loggers.topic
+        });
+        await events.load({});
+        await i18n.load({
+            loadPath: path.resolve(rootFolderPath, configs.loaders.localization.loadPath),
+            fallbackLang: configs.loaders.localization.fallbackLang,
+            preloadLang: configs.loaders.localization.preloadLangs
         });
-        resolvedTmpFileJson = tmpFileObject.getResolvedTmpFile();
-        r = resolvedTmpFileJson;
-        response = {
-            _: r
-        };
-        rootFolderPath = resolvedTmpFileJson.configs.rootFolderPath;
-        // => LOADER
-        const serviceName = r.configs.service;
-        const nodeEnv = process.env.NODE_ENV;
-        try {
-            x.set({
-                service: SystemService,
-                reference: SystemService
-            });
-            x.set({
-                service: ConfigsService,
-                reference: ConfigsService
-            });
-            x.set({
-                service: LoggerService,
-                reference: LoggerService
-            });
-            x.set({
-                service: EventsService,
-                reference: EventsService
-            });
-            x.set({
-                service: LocalizationsService,
-                reference: LocalizationsService
-            });
-            await x.get(SystemService).load({
-                tmp: response
-            });
-            await x.get(ConfigsService).load({
-                tmpFolderPath: rootFolderPath,
-                systemService: x.get(SystemService),
-                envLoadPath: `${rootFolderPath}/${r.configs.loaders.configs.envLoadPath}`,
-                ...(r.configs.loaders.configs.globalEnvFileName ? { globalEnvFileName: r.configs.loaders.configs.globalEnvFileName } : null)
-            });
-            await x.get(LoggerService).load({
-                loadPath: `${rootFolderPath}/${r.configs.loaders.loggers.loadPath}`,
-                loggerLevel: systemLoggerLayer || r.configs.loaders.loggers.logLevel,
-                serviceName,
-                env: nodeEnv,
-                kafkaBrokers: kafkaBrokers || '',
-                kafkaTopic: r.configs.loaders.loggers.topic
-            });
-            await x.get(EventsService).load({});
-            await x.get(LocalizationsService).load({
-                loadPath: path.resolve(`${rootFolderPath}/${r.configs.loaders.localization.loadPath}`),
-                fallbackLang: r.configs.loaders.localization.fallbackLang,
-                preloadLang: r.configs.loaders.localization.preloadLangs,
-            });
-        }
-        catch (error) {
-            console.log(`x:${error}`);
-        }
-        //
         coreHasRun = true;
-        return response;
+        return { _: r };
     }
     catch (error) {
-        console.error(`${packageName} x:`, error?.message);
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        console.error(`[${packageName} core failure]: ${errorMessage}`);
     }
 };
-export { webpack, webpackMerge, nodeExternals, MiniCssExtractPlugin };
 export default coreLoader;

package/source/utils/constants/index.js

@@ -1,6 +1,6 @@
 import path from 'path';
 import { __dirname } from '../helpers/path';
-export const packageName = 'tmp-project-tool';
+export const packageName = 'x';
 export const tmpFileDefaultMainFolderName = 'x';
 export const tmpFileDefaultName = 'tmp';
 export const tmpFileDefaultExt = '.yml';

package/source/utils/models/classes/class.tmp-file-loader.d.ts

@@ -1,11 +1,8 @@
-import EventEmitter from "events";
+import { EventEmitter } from "node:events";
 export declare class TmpFileLoader extends EventEmitter {
-    protected tmpFileJson: Record<string, any>;
-    private filePath;
+    #private;
     constructor({ filePath }: {
         filePath: string;
     });
-    private load;
-    private watch;
-    getResolvedTmpFile(): Record<string, any>;
+    getResolvedTmpFile(): any;
 }

package/source/utils/models/classes/class.tmp-file-loader.js

@@ -1,38 +1,38 @@
-import EventEmitter from "events";
-import path from "path";
-import fs from "fs";
-import yaml from 'yaml';
+import { EventEmitter } from "node:events";
+import { resolve } from "node:path";
+import { readFileSync, watchFile } from "node:fs";
+import { parse } from "yaml";
 import { resolveObjWithHandlebars } from "../../helpers";
 export class TmpFileLoader extends EventEmitter {
-    tmpFileJson = {};
-    filePath;
+    #tmpFileJson = {};
+    #filePath;
     constructor({ filePath }) {
         super();
-        this.filePath = path.resolve(filePath);
-        this.load();
-        this.watch();
+        this.#filePath = resolve(filePath);
+        this.#loadSync();
+        this.#initWatcher();
     }
-    load() {
+    #loadSync() {
         try {
-            const bufferFile = fs.readFileSync(this.filePath);
-            const parsedYaml = yaml.parse(bufferFile.toString());
-            this.tmpFileJson = parsedYaml;
-            this.emit("reload", parsedYaml);
+            const content = readFileSync(this.#filePath, "utf8");
+            this.#tmpFileJson = parse(content);
+            this.emit("reload", this.#tmpFileJson);
         }
         catch (err) {
-            console.error("Error:", err);
+            console.error(`[TmpFileLoader] Error: ${err}`);
         }
     }
-    watch() {
-        fs.watchFile(this.filePath, () => {
-            this.load();
+    #initWatcher() {
+        watchFile(this.#filePath, { interval: 500 }, (curr, prev) => {
+            if (curr.mtimeMs !== prev.mtimeMs) {
+                this.#loadSync();
+            }
         });
     }
     getResolvedTmpFile() {
-        if (this.tmpFileJson)
-            return resolveObjWithHandlebars(this.tmpFileJson, this.tmpFileJson);
-        this.load();
-        resolveObjWithHandlebars(this.tmpFileJson, this.tmpFileJson);
-        return this.tmpFileJson;
+        const data = Object.keys(this.#tmpFileJson).length > 0
+            ? this.#tmpFileJson
+            : (this.#loadSync(), this.#tmpFileJson);
+        return resolveObjWithHandlebars(data, data);
     }
 }

package/x/dist/index.d.ts

@@ -0,0 +1,2 @@
+declare let tmp: any;
+export default tmp;

package/x/dist/index.js

@@ -0,0 +1,8 @@
+import coreLoader from "./project/index.js";
+let tmp;
+// => tmp project tool => xrystal
+await (async () => {
+    tmp = await coreLoader();
+})();
+//
+export default tmp;

package/x/dist/loader/configs/index.d.ts

@@ -0,0 +1,13 @@
+import SystemService from '../system/index';
+export default class ConfigsService {
+    protected _globalEnvFileName: string;
+    protected _systemService: SystemService;
+    static tmpFolderPath: string;
+    private _envLoadPath;
+    load: ({ tmpFolderPath, systemService, envLoadPath, globalEnvFileName }: {
+        tmpFolderPath: string;
+        systemService: SystemService;
+        envLoadPath: string;
+        globalEnvFileName?: string | null;
+    }) => any;
+}

package/x/dist/loader/configs/index.js

@@ -0,0 +1,17 @@
+export default class ConfigsService {
+    _globalEnvFileName = 'global';
+    _systemService;
+    static tmpFolderPath;
+    _envLoadPath = '';
+    load = ({ tmpFolderPath, systemService, envLoadPath, globalEnvFileName }) => {
+        ConfigsService.tmpFolderPath = tmpFolderPath;
+        this._systemService = systemService;
+        this._envLoadPath = `${envLoadPath}`;
+        /*
+        this._dynamicEnvLoader({
+            nodeEnv
+            globalEnvFileName
+        })
+        */
+    };
+}