@xrystal/core 3.13.4 → 3.13.6

package/package.json

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

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

@@ -1,10 +1,12 @@
 export declare class X {
     private container;
+    private initializedNames;
     constructor();
     load(patterns: string | string[], verbose?: boolean): this;
     register(Dependency: any): this;
     registerAll(dependencies: any[]): this;
     registerInstance(name: string, instance: any): this;
+    remove(target: string | any): this;
     initialize(input?: {
         service: any;
         props?: any;

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,
@@ -40,9 +41,7 @@ export class X {
                     const className = dependency.name;
                     const name = className.charAt(0).toLowerCase() + className.slice(1);
                     if (!this.isRegistered(name)) {
-                        this.container.register({
-                            [name]: asClass(dependency).singleton()
-                        });
+                        this.container.register({ [name]: asClass(dependency).singleton() });
                         if (verbose)
                             console.log(`[DI] Registered: ${name}`);
                     }
@@ -52,8 +51,6 @@ export class X {
                 console.error(`[DI] Critical: Failed to load module at ${m.path}:`, err.message);
             }
         }
-        if (verbose)
-            console.log('[DI] Load completed. Total registrations:', Object.keys(this.container.registrations).length);
         return this;
     }
     register(Dependency) {
@@ -62,9 +59,7 @@ export class X {
         const name = Dependency.name.charAt(0).toLowerCase() + Dependency.name.slice(1);
         if (this.isRegistered(name))
             return this;
-        this.container.register({
-            [name]: asClass(Dependency).singleton()
-        });
+        this.container.register({ [name]: asClass(Dependency).singleton() });
         return this;
     }
     registerAll(dependencies) {
@@ -74,58 +69,77 @@ export class X {
         return this;
     }
     registerInstance(name, instance) {
-        if (!name || this.isRegistered(name))
+        if (!name)
             return this;
         const formattedName = name.charAt(0).toLowerCase() + name.slice(1);
-        this.container.register({
-            [formattedName]: asValue(instance)
-        });
+        if (this.isRegistered(formattedName))
+            return this;
+        this.container.register({ [formattedName]: asValue(instance) });
+        return this;
+    }
+    remove(target) {
+        const name = typeof target === 'function'
+            ? target.name.charAt(0).toLowerCase() + target.name.slice(1)
+            : target;
+        this.container.register(name, asValue(undefined));
+        this.initializedNames.delete(name);
         return this;
     }
     async initialize(input, verbose = false) {
         const cradle = this.container.cradle;
         const inputList = input ? (Array.isArray(input) ? input : [input]) : [];
-        const propsMap = new Map();
-        const initializedNames = [];
-        inputList.forEach(item => {
-            if (item?.service) {
-                const name = typeof item.service === 'function'
-                    ? item.service.name.charAt(0).toLowerCase() + item.service.name.slice(1)
-                    : item.service;
-                propsMap.set(name, item.props);
+        for (const item of inputList) {
+            if (!item?.service)
+                continue;
+            const name = typeof item.service === 'function'
+                ? item.service.name.charAt(0).toLowerCase() + item.service.name.slice(1)
+                : item.service;
+            if (this.initializedNames.has(name))
+                continue;
+            const instance = cradle[name];
+            if (instance) {
+                if (typeof instance.load === 'function') {
+                    try {
+                        await instance.load(item.props || {});
+                        if (verbose)
+                            console.log(`[DI] Initialized (Priority): ${name}`);
+                    }
+                    catch (err) {
+                        console.error(`[DI] Critical: Priority service "${name}" failed:`, err.message);
+                    }
+                }
+                this.initializedNames.add(name);
             }
-        });
+        }
         for (const key of Object.keys(this.container.registrations)) {
+            if (this.initializedNames.has(key))
+                continue;
             const instance = cradle[key];
             if (instance && typeof instance.load === 'function') {
                 try {
-                    const props = propsMap.get(key) || {};
-                    await instance.load(props);
-                    initializedNames.push(key);
+                    await instance.load({});
+                    if (verbose)
+                        console.log(`[DI] Initialized (Auto): ${key}`);
                 }
                 catch (err) {
-                    console.error(`[DI] Critical: Service "${key}" failed to initialize:`, err.message);
+                    console.error(`[DI] Critical: Auto service "${key}" failed:`, err.message);
                 }
             }
-        }
-        if (verbose && initializedNames.length > 0) {
-            console.log('[DI] Successfully initialized:', initializedNames);
+            this.initializedNames.add(key);
         }
         return this;
     }
     get(target) {
         if (!target)
-            throw new Error('[DI] Target is required for resolution');
+            throw new Error('[DI] Target is required');
         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;
-    }
+    get cradle() { return this.container.cradle; }
     isRegistered(name) {
-        return !!this.container.registrations[name];
+        return !!this.container.registrations[name] && this.container.registrations[name].resolve !== undefined;
     }
 }
 export default new X();