@xrystal/core 3.13.7 → 3.14.0

package/package.json

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

package/source/project/index.js

@@ -19,7 +19,11 @@ const coreLoader = async ({}) => {
         x
             .load([
             path.join(__dirname, '..', 'loader', '**/*.{ts,js}'),
-        ], false)
+        ], {
+            exclude: [
+                path.join(__dirname, '..', 'utils', '**/class.x.{ts,js}'),
+            ]
+        })
             .initialize([
             {
                 service: SystemService,

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

@@ -2,7 +2,11 @@ export declare class X {
     private container;
     private initializedNames;
     constructor();
-    load(patterns: string | string[], verbose?: boolean): this;
+    private getSource;
+    load(patterns: string | string[], options?: {
+        verbose?: boolean;
+        exclude?: string | Function | (string | Function)[];
+    }): this;
     register(Dependency: any): this;
     registerAll(dependencies: any[]): this;
     registerInstance(name: string, instance: any): this;

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

@@ -9,43 +9,29 @@ export class X {
             strict: true
         });
     }
-    load(patterns, verbose = false) {
-        if (!patterns) {
-            if (verbose)
-                console.warn('[DI] load() çağrıldı ama patterns undefined.');
-            return this;
-        }
+    getSource(filePath) {
+        const projectRoot = process.cwd().replace(/\\/g, '/');
+        const normalizedPath = filePath.replace(/\\/g, '/');
+        return normalizedPath.includes('node_modules') || !normalizedPath.startsWith(projectRoot) ? 'LIB' : 'APP';
+    }
+    load(patterns, options = {}) {
+        const { verbose = false, exclude = [] } = options;
         const cwd = process.cwd();
-        if (!cwd) {
-            console.error('[DI] Critical: process.cwd() undefined döndü!');
-            return this;
-        }
-        const input = Array.isArray(patterns) ? patterns : [patterns];
-        const resolvedPatterns = [];
-        for (const p of input) {
-            if (typeof p !== 'string') {
-                console.error(`[DI] Critical: load() metoduna geçersiz path gönderildi. Beklenen: string, Gelen: ${typeof p}`, p);
-                continue;
-            }
-            try {
-                const resolved = path.isAbsolute(p) ? p : path.resolve(cwd, p);
-                resolvedPatterns.push(resolved.replace(/\\/g, '/'));
-            }
-            catch (err) {
-                console.error(`[DI] Path resolve hatası (${p}):`, err.message);
-            }
-        }
-        if (resolvedPatterns.length === 0)
-            return this;
+        const excludeList = Array.isArray(exclude) ? exclude : [exclude];
+        const resolvedPatterns = (Array.isArray(patterns) ? patterns : [patterns]).map(p => {
+            const resolved = path.isAbsolute(p) ? p : path.resolve(cwd, p);
+            return resolved.replace(/\\/g, '/');
+        });
         let modules = [];
         try {
             modules = listModules(resolvedPatterns);
         }
         catch (err) {
-            console.error(`[DI] Critical: listModules patladı. Patternlar:`, resolvedPatterns, err.message);
+            console.error(`[DI][CRITICAL] Path resolution failed: ${err.message}`);
             return this;
         }
         for (const m of modules) {
+            const source = this.getSource(m.path);
             if (m.path === __filename || m.path.endsWith('.d.ts') || m.path.endsWith('.map'))
                 continue;
             try {
@@ -54,6 +40,20 @@ export class X {
                 if (!dependency) {
                     dependency = Object.values(loaded).find(val => typeof val === 'function' && !!val.prototype && !!val.name);
                 }
+                const isExcluded = excludeList.some(ex => {
+                    if (typeof ex === 'string') {
+                        return m.path.includes(ex) || m.name === ex;
+                    }
+                    if (typeof ex === 'function') {
+                        return dependency === ex;
+                    }
+                    return false;
+                });
+                if (isExcluded) {
+                    if (verbose)
+                        console.log(`[DI][${source}] Excluded: ${m.name}`);
+                    continue;
+                }
                 const isClass = typeof dependency === 'function' && !!dependency.prototype && !!dependency.name;
                 if (isClass) {
                     const className = dependency.name;
@@ -61,21 +61,19 @@ export class X {
                     if (!this.isRegistered(name)) {
                         this.container.register({ [name]: asClass(dependency).singleton() });
                         if (verbose)
-                            console.log(`[DI] Registered: ${name}`);
+                            console.log(`[DI][${source}] Registered: ${name}`);
                     }
                 }
             }
             catch (err) {
-                console.error(`[DI] Critical: Modül yüklenemedi (${m.path}):`, err.message);
+                console.error(`[DI][${source}] Load Error in ${m.name}:`, err.message);
             }
         }
         return this;
     }
     register(Dependency) {
-        if (!Dependency || !Dependency.name) {
-            console.error('[DI] register() başarısız: Geçersiz sınıf.', Dependency);
+        if (!Dependency?.name)
             return this;
-        }
         const name = Dependency.name.charAt(0).toLowerCase() + Dependency.name.slice(1);
         if (this.isRegistered(name))
             return this;
@@ -83,16 +81,13 @@ export class X {
         return this;
     }
     registerAll(dependencies) {
-        if (!Array.isArray(dependencies))
-            return this;
-        dependencies.forEach(dep => this.register(dep));
+        if (Array.isArray(dependencies))
+            dependencies.forEach(dep => this.register(dep));
         return this;
     }
     registerInstance(name, instance) {
-        if (!name) {
-            console.error('[DI] registerInstance() başarısız: İsim boş.');
+        if (!name)
             return this;
-        }
         const formattedName = name.charAt(0).toLowerCase() + name.slice(1);
         if (this.isRegistered(formattedName))
             return this;
@@ -102,52 +97,45 @@ export class X {
     async initialize(input, verbose = false) {
         const cradle = this.container.cradle;
         const inputList = input ? (Array.isArray(input) ? input : [input]) : [];
+        const propsMap = new Map();
         for (const item of inputList) {
-            if (!item || !item.service)
+            if (!item?.service)
                 continue;
-            const name = typeof item.service === 'function'
-                ? item.service.name.charAt(0).toLowerCase() + item.service.name.slice(1)
-                : item.service;
-            if (!name || this.initializedNames.has(name))
-                continue;
-            const instance = cradle[name];
-            if (instance && typeof instance.load === 'function') {
-                try {
-                    await instance.load(item.props || {});
-                    this.initializedNames.add(name);
-                    if (verbose)
-                        console.log(`[DI] Initialized (Priority): ${name}`);
-                }
-                catch (err) {
-                    console.error(`[DI] Critical: Priority service "${name}" failed:`, err.message);
-                }
-            }
+            const name = typeof item.service === 'function' ? item.service.name.charAt(0).toLowerCase() + item.service.name.slice(1) : item.service;
+            if (name)
+                propsMap.set(name, item.props);
         }
-        for (const key of Object.keys(this.container.registrations)) {
+        const registrationKeys = Object.keys(this.container.registrations);
+        const allKeys = new Set([...propsMap.keys(), ...registrationKeys]);
+        for (const key of allKeys) {
             if (this.initializedNames.has(key))
                 continue;
             const instance = cradle[key];
             if (instance && typeof instance.load === 'function') {
+                const source = instance.constructor && instance.constructor.name ? 'APP' : 'LIB';
                 try {
-                    await instance.load({});
+                    const props = propsMap.get(key) || {};
+                    await instance.load(props);
                     this.initializedNames.add(key);
                     if (verbose)
-                        console.log(`[DI] Initialized (Auto): ${key}`);
+                        console.log(`[DI][${source}] Initialized: ${key}`);
                 }
                 catch (err) {
-                    console.error(`[DI] Critical: Auto service "${key}" failed:`, err.message);
+                    console.error(`[DI][${source}] Initialization Failed: ${key} ->`, err.message);
                 }
             }
         }
         return this;
     }
     get(target) {
-        if (!target)
-            throw new Error('[DI] get() çağrıldı ama hedef (target) undefined.');
-        const resolveName = typeof target === 'function'
-            ? target.name.charAt(0).toLowerCase() + target.name.slice(1)
-            : target;
-        return this.container.resolve(resolveName);
+        try {
+            const resolveName = typeof target === 'function' ? target.name.charAt(0).toLowerCase() + target.name.slice(1) : target;
+            return this.container.resolve(resolveName);
+        }
+        catch (err) {
+            console.error(`[DI][ERROR] Resolution Failed:`, err.message);
+            throw err;
+        }
     }
     get cradle() { return this.container.cradle; }
     isRegistered(name) {