@xrystal/core 3.18.0 → 3.18.6

package/bin/constants/index.mjs

@@ -1,14 +1,17 @@
-import path from 'path'
+import path from "node:path"
 
-import { __filename, __dirname } from '../helpers/index.mjs'
+export class Constants {
+    static packageName = '@xrystal/core'
 
-export const packageName = '@xrystal/core'
+    static defaultRootFolderName = 'x'
+    static defaultTmpFileName = 'tmp'
+    static defaultTmpFileExt = '.yml'
 
-export const tmpFileDefaultMainFolderName = 'x'
-export const tmpFileDefaultName = 'tmp'
-export const tmpFileDefaultExt = '.yml'
+    static defaultTmpFilePath = path.join(__dirname, `../../${Constants.defaultRootFolderName}/${Constants.defaultTmpFileName}.${Constants.defaultTmpFileExt}`)
+    static defaultOwnerTmpFilePath = path.join(process.cwd(),`./${Constants.defaultRootFolderName}/${Constants.defaultTmpFileName}.${Constants.defaultTmpFileExt}`)
 
-export const defaultTmpFilePath = path.resolve(__dirname(__filename(import.meta.url)), `../../${tmpFileDefaultMainFolderName}/${tmpFileDefaultName}.yml`)
-export const defaultOwnerTmpFilePath = path.resolve(`./${tmpFileDefaultMainFolderName}/${tmpFileDefaultName}.yml`)
+    static publicFolderName = 'public'
+    static kafkaLogsTopic = 'logs'
 
-export const templateRepoUri = 'https://github.com/xdloper/xastral-general-project-tmp.git'
+    static templateRepoUri = 'https://github.com/xdloper/xastral-general-project-tmp.git'
+}

package/bin/main-cli.js

@@ -8,128 +8,124 @@ 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 { Constants } from "./constants/index.mjs"
 import { findFileRecursively, resolveObjWithHandlebars } from "./helpers/index.mjs"
 
 const setupCLI = async () => {
-  const cli = new Command()
+    const cli = new Command()
+
+    const isBun = !!process.versions.bun
+    const runtimeName = isBun ? "Bun" : "Node.js"
+    const packageManager = isBun ? "bun" : "npm"
+    const installCommand = isBun ? "bun install" : "npm install"
+    const devCommand = isBun ? "bun run dev:local" : "npm run dev:local"
+
+    try {
+        let ownerTmpFilePath = findFileRecursively(".", Constants.defaultTmpFileName, Constants.defaultTmpFileExt)
+
+        if (!ownerTmpFilePath) {
+            if (!Constants.defaultTmpFilePath || !fs.existsSync(Constants.defaultTmpFilePath)) {
+                throw new Error("Default template configuration file not found in package")
+            }
+
+            const folderPath = path.resolve(Constants.defaultRootFolderName)
+            if (!fs.existsSync(folderPath)) {
+                fs.mkdirSync(folderPath, { recursive: true })
+            }
+
+            const tmpFilePathBuffer = fs.readFileSync(Constants.defaultTmpFilePath)
+            fs.writeFileSync(Constants.defaultOwnerTmpFilePath, tmpFilePathBuffer)
+            ownerTmpFilePath = Constants.defaultOwnerTmpFilePath
+        }
 
-  const isBun = !!process.versions.bun
-  const runtimeName = isBun ? "Bun" : "Node.js"
-  const packageManager = isBun ? "bun" : "npm"
-  const installCommand = isBun ? "bun install" : "npm install"
-  const devCommand = isBun ? "bun run dev:local" : "npm run dev:local"
+        const ownerTmpFile = fs.readFileSync(ownerTmpFilePath, "utf8")
+        const parsedTmpObject = yaml.parse(ownerTmpFile)
+        const resolvedTmpObject = resolveObjWithHandlebars(parsedTmpObject, parsedTmpObject)
 
-  try {
-    let ownerTmpFilePath = findFileRecursively(".", tmpFileDefaultName, tmpFileDefaultExt)
+        cli
+            .command("create <project-name> [target-path]")
+            .description(`Project initializer using ${runtimeName}`)
+            .action(async (projectName, targetDir) => {
+                let targetPath = ""
+                const isCurrentDir = projectName === "."
 
-    if (!ownerTmpFilePath) {
-      if (!defaultTmpFilePath || !fs.existsSync(defaultTmpFilePath)) {
-        throw new Error("Default template configuration file not found in package")
-      }
+                if (targetDir) {
+                    const baseDir = path.resolve(process.cwd(), targetDir)
+                    targetPath = isCurrentDir ? baseDir : path.join(baseDir, projectName)
+                } else {
+                    targetPath = isCurrentDir ? process.cwd() : path.resolve(process.cwd(), projectName)
+                }
 
-      const tmpFilePathBuffer = fs.readFileSync(defaultTmpFilePath)
-      const folderPath = path.resolve(tmpFileDefaultMainFolderName || ".xrystal")
+                if (fs.existsSync(targetPath) && fs.readdirSync(targetPath).length > 0) {
+                    console.log(chalk.red(`❌ Error: Target directory '${targetPath}' is not empty!`))
+                    process.exit(1)
+                }
 
-      if (!fs.existsSync(folderPath)) {
-        fs.mkdirSync(folderPath, { recursive: true })
-      }
+                const mainPath = resolvedTmpObject?.configs?.mainFolderPath || "./source"
 
-      fs.writeFileSync(defaultOwnerTmpFilePath, tmpFilePathBuffer)
-      ownerTmpFilePath = defaultOwnerTmpFilePath
-    }
+                if (!fs.existsSync(targetPath)) {
+                    fs.mkdirSync(targetPath, { recursive: true })
+                }
 
-    const ownerTmpFile = fs.readFileSync(ownerTmpFilePath, "utf8")
-    const parsedTmpObject = yaml.parse(ownerTmpFile)
-    const resolvedTmpObject = resolveObjWithHandlebars(parsedTmpObject, parsedTmpObject)
+                const spinner = ora(`${runtimeName} environment detected. Cloning template...`).start()
 
-    const mainPath = resolvedTmpObject?.configs?.mainFolderPath || "./source"
-    const projectMainFolderPath = path.resolve(mainPath)
+                try {
+                    execSync(`git clone --depth 1 ${Constants.templateRepoUri} "${targetPath}"`, { stdio: "ignore" })
 
-    if (!fs.existsSync(projectMainFolderPath)) {
-      fs.mkdirSync(projectMainFolderPath, { recursive: true })
-    }
+                    const gitFolder = path.join(targetPath, ".git")
+                    if (fs.existsSync(gitFolder)) {
+                        fs.rmSync(gitFolder, { recursive: true, force: true })
+                    }
 
-    cli
-      .command("create <project-name> [target-path]")
-      .description(`Project initializer using ${runtimeName}`)
-      .action(async (projectName, targetDir) => {
-        let targetPath = ""
-        const isCurrentDir = projectName === "."
-
-        if (targetDir) {
-          const baseDir = path.resolve(process.cwd(), targetDir)
-          targetPath = isCurrentDir ? baseDir : path.join(baseDir, projectName)
-        } else {
-          targetPath = isCurrentDir ? process.cwd() : path.resolve(process.cwd(), projectName)
-        }
+                    try {
+                        execSync(`git init`, { cwd: targetPath, stdio: "ignore" })
+                    } catch (e) {
+                        // Git init fail
+                    }
 
-        if (fs.existsSync(targetPath) && fs.readdirSync(targetPath).length > 0) {
-          console.log(chalk.red(`❌ Error: Target directory '${targetPath}' is not empty!`))
-          process.exit(1)
-        }
-
-        if (!fs.existsSync(targetPath)) {
-          fs.mkdirSync(targetPath, { recursive: true })
-        }
+                    const projectMainFolderPath = path.resolve(targetPath, mainPath)
+                    if (!fs.existsSync(projectMainFolderPath)) {
+                        fs.mkdirSync(projectMainFolderPath, { recursive: true })
+                    }
 
-        const spinner = ora(`${runtimeName} environment detected. Cloning template...`).start()
+                    spinner.succeed(chalk.green("Template cloned and git initialized!"))
+                    console.log(chalk.blue(`\n📦 Installing dependencies with ${packageManager}...`))
 
-        try {
-          execSync(`git clone --depth 1 ${templateRepoUri} "${targetPath}"`, { stdio: "ignore" })
+                    execSync(installCommand, { cwd: targetPath, stdio: "inherit" })
 
-          const gitFolder = path.join(targetPath, ".git")
-          if (fs.existsSync(gitFolder)) {
-            fs.rmSync(gitFolder, { recursive: true, force: true })
-          }
+                    console.log(chalk.green("\n✅ Done!"))
 
-          try {
-            execSync(`git init`, { cwd: targetPath, stdio: "ignore" })
-          } catch (e) {
-          }
+                    const relativePath = path.relative(process.cwd(), targetPath)
+                    if (relativePath && relativePath !== ".") {
+                        console.log(chalk.cyan(`\n   cd ${relativePath}`))
+                    }
+                    console.log(chalk.cyan(`   ${devCommand}`))
 
-          spinner.succeed(chalk.green("Template cloned and git initialized!"))
-          console.log(chalk.blue(`\n📦 Installing dependencies with ${packageManager}...`))
+                } catch (err) {
+                    spinner.fail(chalk.red("Failed!"))
+                    console.error(chalk.red(`\nDetails: ${err.message}`))
 
-          execSync(installCommand, { cwd: targetPath, stdio: "inherit" })
+                    if (fs.existsSync(targetPath) && !isCurrentDir) {
+                        const files = fs.readdirSync(targetPath)
 
-          console.log(chalk.green("\n✅ Done!"))
+                        if (files.length < 5) {
+                            fs.rmSync(targetPath, { recursive: true, force: true })
+                            console.log(chalk.yellow(`🧹 Cleaned up failed installation at ${targetPath}`))
+                        }
+                    }
+                }
+            })
 
-          const relativePath = path.relative(process.cwd(), targetPath)
-          if (relativePath && relativePath !== ".") {
-            console.log(chalk.cyan(`\n   cd ${relativePath}`))
-          }
+        cli.parse(process.argv)
 
-          console.log(chalk.cyan(`   ${devCommand}`))
-
-        } catch (err) {
-          spinner.fail(chalk.red("Failed!"))
-          console.error(chalk.red(`\nDetails: ${err.message}`))
-
-          if (fs.existsSync(targetPath) && targetPath !== process.cwd() && fs.readdirSync(targetPath).length === 0) {
-            fs.rmSync(targetPath, { recursive: true, force: true })
-          }
-        }
-      })
-
-    cli.parse(process.argv)
-
-  } catch (error) {
-    console.error(`${packageName || "CLI"} Initialization Error:`, error?.message)
-  }
+    } catch (error) {
+        console.error(`${Constants.packageName || "CLI"} Initialization Error:`, error?.message)
+    }
 }
 
 process.on("uncaughtException", (error) => {
-  console.error("Critical Error:", error.message)
-  process.exit(1)
+    console.error("Critical Error:", error.message)
+    process.exit(1)
 })
 
 setupCLI()

package/package.json

@@ -1,7 +1,7 @@
 {
   "author": "Yusuf Yasir KAYGUSUZ",
   "name": "@xrystal/core",
-  "version": "3.18.0",
+  "version": "3.18.6",
   "description": "Project core for xrystal",
   "publishConfig": {
     "access": "public",

package/source/loader/configs/index.d.ts

@@ -1,13 +1,39 @@
 import SystemService from '../system/index';
 import { IService } from '../../utils';
+export interface IConfig {
+    worker: boolean;
+    nodeEnv: string;
+    debug: string;
+    https: string;
+    httpsfileEncoding: string;
+    httpsCertfile: string;
+    httpsKeyfile: string;
+    rootFolderPath: string;
+    projectName: string;
+    serviceName: string;
+    projectNamePrefixEnv: string;
+    projectNameEnv: string;
+    projectNameSuffixEnv: string;
+    systemStaticFolderPath: string;
+    systemLoggerLayer: string;
+    kafkaBrokers: string;
+    kafkaLogsTopic: string;
+    baseApiUri: string;
+    port: number;
+    internalSecret: string;
+    secret: string;
+    cwd: string;
+    env: string;
+}
 export default class ConfigsService implements IService {
     #private;
     private config;
-    publicFolderName: string;
-    kafkaLogsTopic: string;
+    readonly publicFolderName: string;
+    readonly kafkaLogsTopic: string;
     constructor({ systemService }: {
         systemService: SystemService;
     });
     load: ({}: {}) => void;
-    get all(): Record<string, any>;
+    setConfig(newConfigs: any): void;
+    get all(): IConfig;
 }

package/source/loader/configs/index.js

@@ -1,9 +1,9 @@
 import path from 'node:path';
-import { kafkaLogsTopic, publicFolderName } from '../../utils';
+import { Constants } from '../../utils';
 export default class ConfigsService {
-    config = {};
-    publicFolderName = publicFolderName;
-    kafkaLogsTopic = kafkaLogsTopic;
+    config;
+    publicFolderName = Constants.publicFolderName;
+    kafkaLogsTopic = Constants.kafkaLogsTopic;
     #systemService;
     constructor({ systemService }) {
         this.#systemService = systemService;
@@ -13,7 +13,7 @@ export default class ConfigsService {
         const rawConfigs = tmp?.configs || tmp?.configs || {};
         this.config = {
             worker: process.env.WORKER === 'true' ? true : false || false,
-            nodeEnv: process.env.NODE_ENV === 'true' ? true : false || false,
+            nodeEnv: process.env.NODE_ENV,
             debug: process.env.SYSTEM_LOGGER_LAYER,
             https: process.env.HTTPS,
             httpsfileEncoding: process.env.ENCODING || 'utf8',
@@ -34,10 +34,16 @@ export default class ConfigsService {
             internalSecret: process.env.INTERNAL_SECRET,
             secret: process.env.SECRET,
             cwd: process.cwd(),
-            env: process.env.NODE_ENV,
-            ...rawConfigs
+            env: process.env.NODE_ENV
         };
     };
+    setConfig(newConfigs) {
+        const mergedData = {
+            ...this.config,
+            ...newConfigs
+        };
+        this.config = Object.freeze(mergedData);
+    }
     get all() {
         return this.config;
     }

package/source/loader/logger/index.d.ts

@@ -2,11 +2,11 @@ import winston from "winston";
 import "winston-daily-rotate-file";
 import { AsyncLocalStorage } from "node:async_hooks";
 import { LoggerLayerEnum, IService } from "../../utils";
-interface CustomLogger extends winston.Logger {
+export interface ICustomLogger extends winston.Logger {
     critical: winston.LeveledLogMethod;
     http: winston.LeveledLogMethod;
 }
-interface LogOptions {
+export interface ILog {
     level: LoggerLayerEnum;
     message: any;
     payload?: any;
@@ -17,9 +17,9 @@ export default class LoggerService implements IService {
     static readonly storage: AsyncLocalStorage<Map<string, string>>;
     private serviceName;
     private kafkaProducer;
-    private kafkaTopic;
+    private kafkaLogsTopic;
     private isKafkaReady;
-    winston: CustomLogger;
+    winston: ICustomLogger;
     constructor({ configsService }: {
         configsService: any;
     });
@@ -27,13 +27,12 @@ export default class LoggerService implements IService {
     winstonLoader: ({ loadPath, loggerLevel }: {
         loadPath: string;
         loggerLevel: string;
-    }) => CustomLogger;
+    }) => ICustomLogger;
     private safeReplacer;
     private getTracingFormat;
     private getConsoleFormat;
     runWithId: <T>(id: string, callback: () => T) => T;
     logToKafka(info: any): Promise<void>;
     log(level: LoggerLayerEnum, message: any, payload?: any, code?: string | number): void;
-    log(options: LogOptions): void;
+    log(options: ILog): void;
 }
-export {};

package/source/loader/logger/index.js

@@ -35,13 +35,13 @@ export default class LoggerService {
     static storage = new AsyncLocalStorage();
     serviceName = "";
     kafkaProducer = null;
-    kafkaTopic = "";
+    kafkaLogsTopic = "";
     isKafkaReady = false;
     winston;
     #configsService;
     constructor({ configsService }) {
         this.#configsService = configsService;
-        this.kafkaTopic = this.#configsService?.all.kafkaTopic;
+        this.kafkaLogsTopic = this.#configsService?.all.kafkaLogsTopic;
         winston.addColors(customColors);
         this.winston = winston.createLogger({
             level: this.#configsService.all.systemLoggerLayer,
@@ -151,9 +151,8 @@ export default class LoggerService {
             return;
         try {
             const { id, level, message, payload, code } = info;
-            console.log('geldii', this.kafkaTopic);
             await this.kafkaProducer.send({
-                topic: this.kafkaTopic,
+                topic: this.kafkaLogsTopic,
                 messages: [{
                         value: JSON.stringify({
                             service: this.serviceName,

package/source/project/index.js

@@ -1,6 +1,6 @@
 import path from 'path';
-import { SystemService, ConfigsService, LoggerService, EventsService, LocalizationsService, ClientsService, ControllerService } from '../loader/index';
-import { packageName, x, getTmp, } from '../utils/index';
+import { SystemService, ConfigsService, LoggerService, EventsService, LocalizationsService, ClientsService, ControllerService } from '../loader';
+import { Constants, x, getTmp, } from '../utils';
 //
 let coreHasRun = false;
 export const core = getTmp();
@@ -68,7 +68,7 @@ const coreLoader = async ({}) => {
     }
     catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);
-        console.error(`[${packageName} core failure]: ${errorMessage}`);
+        console.error(`[${Constants.packageName} core failure]: ${errorMessage}`);
     }
 };
 export default coreLoader;

package/source/utils/constants/index.d.ts

@@ -1,9 +1,10 @@
-export declare const packageName: string;
-export declare const tmpFileDefaultMainFolderName: string;
-export declare const tmpFileDefaultName: string;
-export declare const tmpFileDefaultExt = ".yml";
-export declare const defaultTmpFilePath: string;
-export declare const defaultOwnerTmpFilePath: string;
-export declare const systemLoggerLayer: string;
-export declare const publicFolderName = "public";
-export declare const kafkaLogsTopic = "logs";
+export declare class Constants {
+    static readonly packageName: string;
+    static readonly defaultRootFolderName: string;
+    static readonly defaultTmpFileName: string;
+    static readonly defaultTmpFileExt = ".yml";
+    static readonly defaultTmpFilePath: string;
+    static readonly defaultOwnerTmpFilePath: string;
+    static readonly publicFolderName = "public";
+    static readonly kafkaLogsTopic = "logs";
+}

package/source/utils/constants/index.js

@@ -1,11 +1,11 @@
-import path from 'path';
-import { __dirname } from '../helpers/path';
-export const packageName = 'x';
-export const tmpFileDefaultMainFolderName = 'x';
-export const tmpFileDefaultName = 'tmp';
-export const tmpFileDefaultExt = '.yml';
-export const defaultTmpFilePath = path.resolve(__dirname(import.meta.url), `../../${tmpFileDefaultMainFolderName}/${tmpFileDefaultName}.yml`);
-export const defaultOwnerTmpFilePath = path.resolve(`./${tmpFileDefaultMainFolderName}/${tmpFileDefaultName}.yml`);
-export const systemLoggerLayer = process.env.SYSTEM_LOGGER_LAYER;
-export const publicFolderName = 'public';
-export const kafkaLogsTopic = 'logs';
+import path from "node:path";
+export class Constants {
+    static packageName = '@xrystal/core';
+    static defaultRootFolderName = 'x';
+    static defaultTmpFileName = 'tmp';
+    static defaultTmpFileExt = '.yml';
+    static defaultTmpFilePath = path.join(__dirname, `../../${Constants.defaultRootFolderName}/${Constants.defaultTmpFileName}.${Constants.defaultTmpFileExt}`);
+    static defaultOwnerTmpFilePath = path.join(process.cwd(), `./${Constants.defaultRootFolderName}/${Constants.defaultTmpFileName}.${Constants.defaultTmpFileExt}`);
+    static publicFolderName = 'public';
+    static kafkaLogsTopic = 'logs';
+}

package/source/utils/helpers/tmp/index.d.ts

@@ -13,4 +13,3 @@ export declare const argvsConverter: (argvs: string) => {
 };
 export declare const findExt: (filename: string) => string;
 export declare const changeExtensions: (filename: string, repalceExt: string) => string;
-export declare const webFileFindEngine: (folderPath: string) => string[];

package/source/utils/helpers/tmp/index.js

@@ -1,18 +1,18 @@
 import path from "path";
 import fs from 'fs';
 import Handlebars from 'handlebars';
-import { SupportFileExtensionsEnum, tmpFileDefaultExt, tmpFileDefaultName, TmpFileLoader } from "../../index.js";
+import { Constants, TmpFileLoader } from "../../index.js";
 export const getTmp = () => {
-    const ownerTmpFilePath = findFileRecursively(".", tmpFileDefaultName, tmpFileDefaultExt);
+    const ownerTmpFilePath = findFileRecursively(".", Constants.defaultTmpFileName, Constants.defaultTmpFileExt);
     if (!ownerTmpFilePath) {
-        throw new Error(`${tmpFileDefaultName} file not found`);
+        throw new Error(`${Constants.defaultTmpFileName} file not found`);
     }
     const tmpFileObject = getTmpConfig({});
     return {
         _: tmpFileObject
     };
 };
-export const getTmpConfig = ({ root = '.', tmpFileName = tmpFileDefaultName, ext = '.yml' }) => {
+export const getTmpConfig = ({ root = process.cwd(), tmpFileName = Constants.defaultTmpFileName, ext = Constants.defaultTmpFileExt }) => {
     const path = findFileRecursively(root, tmpFileName, ext);
     if (!path) {
         throw new Error(`${name}.${ext} file not found`);
@@ -95,33 +95,3 @@ export const findExt = (filename) => {
 export const changeExtensions = (filename, repalceExt) => {
     return filename.replace(findExt(filename), repalceExt);
 };
-export const webFileFindEngine = (folderPath) => {
-    try {
-        const files = fs.readdirSync(folderPath);
-        const fullFileExtension = Object.values(SupportFileExtensionsEnum).map(ext => '.' + ext);
-        const filteredFiles = [];
-        files.forEach(file => {
-            const filePath = path.join(folderPath, file);
-            const isDirectory = fs.statSync(filePath).isDirectory();
-            if (isDirectory) {
-                const subFolderFiles = webFileFindEngine(filePath);
-                subFolderFiles.forEach(subFile => {
-                    filteredFiles.push(path.join(file, subFile).split('\\').join('/')); // Alt klasördeki dosya yolunu, ana klasör yoluna ekleyerek dosyları benzersiz yapıyoruz sonda ise diğer işletim sistemlerien uygun hale getiriyoruz
-                });
-            }
-            else {
-                for (const ffn of fullFileExtension) {
-                    if (file.endsWith(ffn)) {
-                        filteredFiles.push(file);
-                        break;
-                    }
-                }
-            }
-        });
-        return filteredFiles;
-    }
-    catch (error /* unknow */) {
-        console.error('Error: ', error.message);
-        return [];
-    }
-};

package/source/utils/models/classes/class.x.d.ts

@@ -1,5 +1,5 @@
 import { LifetimeType } from 'awilix';
-export declare class X {
+declare class X {
     private container;
     private initializedNames;
     constructor();
@@ -12,14 +12,14 @@ export declare class X {
     register(Dependency: any, lifetime?: LifetimeType): this;
     registerAll(dependencies: any[], lifetime?: LifetimeType): this;
     registerInstance(name: string, instance: any): this;
-    initialize(input?: {
+    initialize<T = any>(input?: {
         service: any;
-        props?: any;
+        props?: T;
     } | {
         service: any;
-        props?: any;
+        props?: T;
     }[], verbose?: boolean): Promise<this>;
-    get<T>(target: string | any): T;
+    get<T>(target: any): T;
     get cradle(): any;
     private isRegistered;
 }

package/source/utils/models/classes/class.x.js

@@ -1,7 +1,7 @@
 import { createContainer, asClass, asValue, InjectionMode, listModules, Lifetime } from 'awilix';
 import path from 'node:path';
 import { pathToFileURL } from 'node:url';
-export class X {
+class X {
     container;
     initializedNames = new Set();
     constructor() {
@@ -28,7 +28,6 @@ export class X {
             modules = listModules(resolvedPatterns);
         }
         catch (err) {
-            console.error(`[DI][CRITICAL] Path resolution failed: ${err.message}`);
             return this;
         }
         for (const m of modules) {
@@ -43,11 +42,8 @@ export class X {
                 }
                 return false;
             });
-            if (isPathExcluded) {
-                if (verbose)
-                    console.log(`[DI][${source}] Excluded: ${m.name}`);
+            if (isPathExcluded)
                 continue;
-            }
             try {
                 const fileUrl = pathToFileURL(m.path).href;
                 const loaded = await import(fileUrl);
@@ -66,14 +62,12 @@ export class X {
                         this.container.register({
                             [name]: asClass(dependency).setLifetime(lifetime)
                         });
-                        if (verbose)
-                            console.log(`[DI][${source}] Registered: ${name}`);
                     }
                 }
             }
             catch (err) {
                 if (verbose)
-                    console.error(`[DI][${source}] Load Error in ${m.name}:`, err.message);
+                    console.error(`[DI][${source}] Load Error:`, err.message);
             }
         }
         return this;
@@ -126,8 +120,6 @@ export class X {
                     const props = propsMap.get(key) || {};
                     await instance.load(props);
                     this.initializedNames.add(key);
-                    if (verbose)
-                        console.log(`[DI] Initialized: ${key}`);
                 }
                 catch (err) {
                     console.error(`[DI] Initialization Failed: ${key} ->`, err.message);

package/source/utils/models/enums/index.d.ts

@@ -118,22 +118,3 @@ export declare enum EndpointResourceEnum {
     WEBHOOKS = "webhooks",
     OTHERS = "others"
 }
-export declare enum SupportFileExtensionsEnum {
-    'HTML' = "html",
-    'EJS' = "ejs",
-    'HBS' = "hbs",
-    "TS" = "",
-    "JS" = ".js",
-    "TSX" = "x",
-    "JSX" = ".jsx",
-    "TTF" = ".ttf",
-    "EOT" = ".eot",
-    "OTF" = ".otf",
-    "SVG" = ".svg",
-    "PNG" = ".png",
-    "WOFF" = ".woff",
-    "WOFF2" = ".woff2",
-    "CSS" = ".css",
-    "SCSS" = ".scss",
-    "SASS" = ".sass"
-}

package/source/utils/models/enums/index.js

@@ -137,23 +137,3 @@ export var EndpointResourceEnum;
     EndpointResourceEnum["WEBHOOKS"] = "webhooks";
     EndpointResourceEnum["OTHERS"] = "others";
 })(EndpointResourceEnum || (EndpointResourceEnum = {}));
-export var SupportFileExtensionsEnum;
-(function (SupportFileExtensionsEnum) {
-    SupportFileExtensionsEnum["HTML"] = "html";
-    SupportFileExtensionsEnum["EJS"] = "ejs";
-    SupportFileExtensionsEnum["HBS"] = "hbs";
-    SupportFileExtensionsEnum["TS"] = "";
-    SupportFileExtensionsEnum["JS"] = ".js";
-    SupportFileExtensionsEnum["TSX"] = "x";
-    SupportFileExtensionsEnum["JSX"] = ".jsx";
-    SupportFileExtensionsEnum["TTF"] = ".ttf";
-    SupportFileExtensionsEnum["EOT"] = ".eot";
-    SupportFileExtensionsEnum["OTF"] = ".otf";
-    SupportFileExtensionsEnum["SVG"] = ".svg";
-    SupportFileExtensionsEnum["PNG"] = ".png";
-    SupportFileExtensionsEnum["WOFF"] = ".woff";
-    SupportFileExtensionsEnum["WOFF2"] = ".woff2";
-    SupportFileExtensionsEnum["CSS"] = ".css";
-    SupportFileExtensionsEnum["SCSS"] = ".scss";
-    SupportFileExtensionsEnum["SASS"] = ".sass";
-})(SupportFileExtensionsEnum || (SupportFileExtensionsEnum = {}));

package/source/utils/models/index.d.ts

@@ -1,4 +1,4 @@
-import x, { X } from './classes/class.x';
+import x from './classes/class.x';
 import locator, { Locator } from './classes/class.service-locator';
 export * from './classes/class.tmp-file-loader';
 export * from './classes/class.response';
@@ -6,4 +6,4 @@ export * from './classes/class.services';
 export * from './classes/class.interfaces';
 export * from './types';
 export * from './enums';
-export { x, X, locator, Locator };
+export { x, locator, Locator };

package/source/utils/models/index.js

@@ -1,4 +1,4 @@
-import x, { X } from './classes/class.x';
+import x from './classes/class.x';
 import locator, { Locator } from './classes/class.service-locator';
 export * from './classes/class.tmp-file-loader';
 export * from './classes/class.response';
@@ -6,4 +6,4 @@ export * from './classes/class.services';
 export * from './classes/class.interfaces';
 export * from './types';
 export * from './enums';
-export { x, X, locator, Locator };
+export { x, locator, Locator };