@xrystal/core 3.13.5 → 3.13.7

package/package.json

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

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

@@ -1,5 +1,6 @@
 export declare class X {
     private container;
+    private initializedNames;
     constructor();
     load(patterns: string | string[], verbose?: boolean): this;
     register(Dependency: any): this;

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

@@ -2,6 +2,7 @@ import { createContainer, asClass, asValue, InjectionMode, listModules } from 'a
 import path from 'node:path';
 export class X {
     container;
+    initializedNames = new Set();
     constructor() {
         this.container = createContainer({
             injectionMode: InjectionMode.PROXY,
@@ -9,21 +10,39 @@ export class X {
         });
     }
     load(patterns, verbose = false) {
-        if (!patterns || (Array.isArray(patterns) && patterns.length === 0))
+        if (!patterns) {
+            if (verbose)
+                console.warn('[DI] load() çağrıldı ama patterns undefined.');
             return this;
+        }
         const cwd = process.cwd();
-        const resolvedPatterns = (Array.isArray(patterns) ? patterns : [patterns])
-            .filter(p => typeof p === 'string')
-            .map(p => {
-            const resolved = path.isAbsolute(p) ? p : path.resolve(cwd, p);
-            return resolved.replace(/\\/g, '/');
-        });
+        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;
         let modules = [];
         try {
             modules = listModules(resolvedPatterns);
         }
         catch (err) {
-            console.error(`[DI] Critical: Path resolution failed: ${err.message}`);
+            console.error(`[DI] Critical: listModules patladı. Patternlar:`, resolvedPatterns, err.message);
             return this;
         }
         for (const m of modules) {
@@ -47,14 +66,16 @@ export class X {
                 }
             }
             catch (err) {
-                console.error(`[DI] Critical: Failed to load module at ${m.path}:`, err.message);
+                console.error(`[DI] Critical: Modül yüklenemedi (${m.path}):`, err.message);
             }
         }
         return this;
     }
     register(Dependency) {
-        if (!Dependency?.name)
+        if (!Dependency || !Dependency.name) {
+            console.error('[DI] register() başarısız: Geçersiz sınıf.', Dependency);
             return this;
+        }
         const name = Dependency.name.charAt(0).toLowerCase() + Dependency.name.slice(1);
         if (this.isRegistered(name))
             return this;
@@ -68,27 +89,32 @@ export class X {
         return this;
     }
     registerInstance(name, instance) {
-        if (!name || this.isRegistered(name))
+        if (!name) {
+            console.error('[DI] registerInstance() başarısız: İsim boş.');
             return this;
+        }
         const formattedName = name.charAt(0).toLowerCase() + name.slice(1);
+        if (this.isRegistered(formattedName))
+            return this;
         this.container.register({ [formattedName]: asValue(instance) });
         return this;
     }
     async initialize(input, verbose = false) {
         const cradle = this.container.cradle;
         const inputList = input ? (Array.isArray(input) ? input : [input]) : [];
-        const initializedNames = new Set();
         for (const item of inputList) {
-            if (!item?.service)
+            if (!item || !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 || {});
-                    initializedNames.add(name);
+                    this.initializedNames.add(name);
                     if (verbose)
                         console.log(`[DI] Initialized (Priority): ${name}`);
                 }
@@ -98,13 +124,13 @@ export class X {
             }
         }
         for (const key of Object.keys(this.container.registrations)) {
-            if (initializedNames.has(key))
+            if (this.initializedNames.has(key))
                 continue;
             const instance = cradle[key];
             if (instance && typeof instance.load === 'function') {
                 try {
                     await instance.load({});
-                    initializedNames.add(key);
+                    this.initializedNames.add(key);
                     if (verbose)
                         console.log(`[DI] Initialized (Auto): ${key}`);
                 }
@@ -117,13 +143,15 @@ export class X {
     }
     get(target) {
         if (!target)
-            throw new Error('[DI] Target is required');
+            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);
     }
     get cradle() { return this.container.cradle; }
-    isRegistered(name) { return !!this.container.registrations[name]; }
+    isRegistered(name) {
+        return !!this.container.registrations[name] && this.container.registrations[name].resolve !== undefined;
+    }
 }
 export default new X();