@adaas/a-concept 0.2.7 → 0.2.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adaas/a-concept",
-  "version": "0.2.7",
+  "version": "0.2.8",
   "description": "A-Concept is a framework of the new generation that is tailored to use AI, enabling developers to create AI-powered applications with ease. It provides a structured approach to building, managing, and deploying AI-driven solutions.",
   "license": "Apache-2.0",
   "main": "./dist/index.cjs",

package/src/global/A-Scope/A-Scope.class.ts

@@ -1814,6 +1814,13 @@ export class A_Scope<
                 this._components.delete(param1.constructor as _ComponentType[number]);
                 A_Context.deregister(param1);
 
+                const ctor = param1.constructor as _ComponentType[number];
+
+                const hasComponent = this._components.has(ctor);
+                if (!hasComponent) {
+                    this.allowedComponents.delete(ctor);
+                }
+
                 break;
             }
             // 3) In case when it's a A-Entity instance
@@ -1821,14 +1828,28 @@ export class A_Scope<
 
                 this._entities.delete(param1.aseid.toString());
                 A_Context.deregister(param1);
+
+                const ctor = param1.constructor as _EntityType[number];
+
+                const hasEntity = Array.from(this._entities.values()).some(entity => entity instanceof ctor);
+                if (!hasEntity) {
+                    this.allowedEntities.delete(ctor);
+                }
+
                 break;
             }
             // 4) In case when it's a A-Fragment instance
             case A_TypeGuards.isFragmentInstance(param1): {
-
                 this._fragments.delete(param1.constructor as A_TYPES__Fragment_Constructor<_FragmentType[number]>);
                 A_Context.deregister(param1);
 
+                const ctor = param1.constructor as A_TYPES__Fragment_Constructor<_FragmentType[number]>;
+
+                const hasFragment = Array.from(this._fragments.values()).some(fragment => fragment instanceof ctor);
+                if (!hasFragment) {
+                    this.allowedFragments.delete(ctor);
+                }
+
                 break;
             }
             // 5) In case when it's a A-Error instance
@@ -1836,6 +1857,14 @@ export class A_Scope<
 
                 this._errors.delete(param1.code);
                 A_Context.deregister(param1);
+
+                const ctor = param1.constructor as _ErrorType[number];
+
+                const hasError = Array.from(this._errors.values()).some(error => error instanceof ctor);
+                if (!hasError) {
+                    this.allowedErrors.delete(ctor);
+                }
+
                 break;
             }
 
@@ -1850,16 +1879,40 @@ export class A_Scope<
             // 8) In case when it's a A-Fragment constructor
             case A_TypeGuards.isFragmentConstructor(param1): {
                 this.allowedFragments.delete(param1 as A_TYPES__Fragment_Constructor<_FragmentType[number]>);
+                // and then deregister all instances of this fragment
+                Array.from(this._fragments.entries()).forEach(([ctor, instance]) => {
+                    if (A_CommonHelper.isInheritedFrom(ctor, param1)) {
+                        this._fragments.delete(ctor);
+                        A_Context.deregister(instance);
+                    }
+                });
+
                 break;
             }
             // 9) In case when it's a A-Entity constructor
             case A_TypeGuards.isEntityConstructor(param1): {
                 this.allowedEntities.delete(param1 as _EntityType[number]);
+                //  and then deregister all instances of this entity
+                Array.from(this._entities.entries()).forEach(([aseid, instance]) => {
+                    if (A_CommonHelper.isInheritedFrom(instance.constructor, param1)) {
+                        this._entities.delete(aseid);
+                        A_Context.deregister(instance);
+                    }
+                });
+
                 break;
             }
             // 10) In case when it's a A-Error constructor
             case A_TypeGuards.isErrorConstructor(param1): {
                 this.allowedErrors.delete(param1 as _ErrorType[number]);
+                // and then deregister all instances of this error
+                Array.from(this._errors.entries()).forEach(([code, instance]) => {
+                    if (A_CommonHelper.isInheritedFrom(instance.constructor, param1)) {
+                        this._errors.delete(code);
+                        A_Context.deregister(instance);
+                    }
+                });
+
                 break;
             }
 
@@ -1875,6 +1928,7 @@ export class A_Scope<
                     `Cannot deregister ${componentName} from the scope ${this.name}`
                 );
         }
+
     }
 
     /**

package/tests/A-Scope.test.ts

@@ -705,4 +705,109 @@ describe('A-Scope tests', () => {
         expect(resolvedA).toBeInstanceOf(MyEntity_B);
         expect(resolvedA?.name).toBe('Entity1');
     });
+
+    it('Should deregister entities properly', async () => {
+
+        class MyEntity extends A_Entity { }
+
+        class MyFragment extends A_Fragment { }
+
+        class MyComponent extends A_Component { }
+
+        const scope = new A_Scope({ name: 'TestScope' });
+
+
+
+        const entity = new MyEntity();
+        const fragment = new MyFragment();
+
+        scope.register(entity);
+        scope.register(fragment);
+        scope.register(MyComponent);
+
+        expect(scope.has(MyEntity)).toBe(true);
+        expect(scope.has(MyFragment)).toBe(true);
+        expect(scope.has(MyComponent)).toBe(true);
+
+        scope.deregister(entity);
+        scope.deregister(fragment);
+        scope.deregister(MyComponent);
+
+        expect(scope.has(MyEntity)).toBe(false);
+        expect(scope.has(MyFragment)).toBe(false);
+        expect(scope.has(MyComponent)).toBe(false);
+    });
+
+    it('Should deregister all entities by class', async () => {
+
+        class BaseEntity extends A_Entity { }
+
+        class MyEntityA extends A_Entity { }
+        class MyEntityB extends BaseEntity { }
+
+
+        const scope = new A_Scope({ name: 'TestScope' });
+
+
+
+        const entityA1 = new MyEntityA();
+        const entityA2 = new MyEntityA();
+        const entityB1 = new MyEntityB();
+
+        scope.register(entityA1);
+        scope.register(entityA2);
+        scope.register(entityB1);
+
+        expect(scope.resolveAll(MyEntityA).length).toBe(2);
+        expect(scope.resolveAll(BaseEntity).length).toBe(1);
+
+        scope.deregister(MyEntityA);
+
+        expect(scope.resolveAll(MyEntityA).length).toBe(0);
+        expect(scope.resolveAll(BaseEntity).length).toBe(1);
+
+        const entityB2 = new MyEntityB();
+        scope.register(entityB2);
+
+        expect(scope.resolveAll(BaseEntity).length).toBe(2);
+
+        scope.deregister(BaseEntity);
+
+        expect(scope.resolveAll(BaseEntity).length).toBe(0);
+    });
+    it('Should register/deregister fragments with the same names', async () => {
+
+        class MyFragment extends A_Fragment {
+
+            array: string[] = [];
+
+            constructor(name: string) {
+                super({ name });
+            }
+        }
+
+        const scope = new A_Scope({ name: 'TestScope' });
+
+        const fragmentA1 = new MyFragment('fragmentA');
+
+        scope.register(fragmentA1);
+
+        expect(scope.has(MyFragment)).toBe(true);
+        expect(scope.resolve(MyFragment)).toBe(fragmentA1);
+
+        scope.deregister(fragmentA1);
+
+        fragmentA1.array.push('newData');
+
+
+        expect(scope.has(MyFragment)).toBe(false);
+
+        const fragmentA2 = new MyFragment('fragmentA');
+
+        scope.register(fragmentA2);
+
+        expect(scope.has(MyFragment)).toBe(true);
+        expect(scope.resolve(MyFragment)).toBe(fragmentA2);
+        expect(fragmentA2.array.length).toBe(0);
+    });
 });