@adaas/a-utils 0.1.32 → 0.1.34

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adaas/a-utils",
-  "version": "0.1.32",
+  "version": "0.1.34",
   "description": "A-Utils is a set of utilities that are used across the ADAAS ecosystem. This package is designed to be a collection of utilities that are used across the ADAAS ecosystem.",
   "license": "Apache-2.0",
   "main": "./dist/index.cjs",

package/src/lib/A-Signal/A-Signal.constants.ts

@@ -1,10 +1,10 @@
 
 export enum A_SignalFeatures {
-    Emit = '_A_SignalFeatures_Emit',
+    Next = '_A_SignalFeatures_Next',
 }
 
 
 
-export enum A_SignalBusFeatures {
-    Emit = '_A_SignalBusFeatures_Emit',
+export enum A_SignalVectorFeatures {
+    Next = '_A_SignalVectorFeatures_Next',
 }

package/src/lib/A-Signal/A-Signal.types.ts

@@ -16,6 +16,9 @@ export type A_SignalConfig_Init = {
      * OR "A_RouterWatcher,A_ScopeWatcher,A_LoggerWatcher"
      */
     stringStructure?: string
+
+
+    propagateSignals?: boolean
 }
 
 

package/src/lib/A-Signal/components/A-SignalBus.component.ts

@@ -1,5 +1,5 @@
 import { A_Caller, A_Component, A_Context, A_Feature, A_Inject, A_Scope } from "@adaas/a-concept";
-import { A_SignalBusFeatures, A_SignalFeatures } from "../A-Signal.constants";
+import { A_SignalFeatures } from "../A-Signal.constants";
 import { A_SignalState } from "../context/A-SignalState.context";
 import { A_SignalConfig } from "../context/A-SignalConfig.context";
 import { A_Config } from "../../A-Config/A-Config.context";
@@ -36,7 +36,7 @@ export class A_SignalBus extends A_Component {
     @A_Feature.Extend({
         scope: [A_Signal]
     })
-    async [A_SignalFeatures.Emit](
+    async [A_SignalFeatures.Next](
         @A_Inject(A_Caller) signal: A_Signal,
         @A_Inject(A_Scope) scope: A_Scope,
 
@@ -90,23 +90,6 @@ export class A_SignalBus extends A_Component {
 
         const vector = state.toVector();
 
-        const nextScope = new A_Scope({
-            name: `A_SignalBus_Next_Scope_of_${this.constructor.name}`,
-            entities: [vector]
-        })
-            .inherit(scope);
-
-        try {
-
-            await this.call(A_SignalBusFeatures.Emit, nextScope);
-
-            nextScope.destroy();
-
-        } catch (error) {
-
-            nextScope.destroy();
-
-            throw error;
-        }
+        await vector.next(scope);
     }
 }

package/src/lib/A-Signal/entities/A-Signal.entity.ts

@@ -54,8 +54,8 @@ export class A_Signal<
      * 
      * @param scope 
      */
-    async emit(scope: A_Scope) {
-        await this.call(A_SignalFeatures.Emit, scope);
+    async next(scope: A_Scope) {
+        await this.call(A_SignalFeatures.Next, scope);
     }
 
 

package/src/lib/A-Signal/entities/A-SignalVector.entity.ts

@@ -1,6 +1,7 @@
-import { A_Entity, A_TYPES__Component_Constructor, A_TYPES__Entity_Constructor } from "@adaas/a-concept";
+import { A_Entity, A_Scope, A_TYPES__Component_Constructor, A_TYPES__Entity_Constructor } from "@adaas/a-concept";
 import { A_SignalVector_Serialized, A_SignalVector_Init } from "../A-Signal.types";
 import { A_Signal } from "./A-Signal.entity";
+import { A_SignalVectorFeatures } from "../A-Signal.constants";
 
 
 /**
@@ -57,6 +58,46 @@ export class A_SignalVector<
     }
 
 
+    /**
+     * Enables iteration over the signals in the vector.
+     * 
+     * @returns 
+     */
+    [Symbol.iterator](): Iterator<TSignals[number]> {
+        let pointer = 0;
+        const signals = this.structure.map((signalConstructor) => {
+            const signalIndex = this._signals.findIndex(s => s.constructor === signalConstructor);
+            return signalIndex !== -1 ? this._signals[signalIndex] : undefined;
+        }) as TSignals[number][];
+
+        return {
+            next(): IteratorResult<TSignals[number]> {
+                if (pointer < signals.length) {
+                    return {
+                        done: false,
+                        value: signals[pointer++]
+                    };
+                } else {
+                    return {
+                        done: true,
+                        value: undefined as any
+                    };
+                }
+            }
+        };
+    }
+
+
+    /**
+     * Emits the signal vector to the specified scope.
+     * 
+     * @param scope
+     */
+    async next(scope: A_Scope): Promise<void> {
+        return await this.call(A_SignalVectorFeatures.Next, scope);
+    }
+
+    
     /**
      * Checks if the vector contains a signal of the specified type.
      * 
@@ -74,22 +115,27 @@ export class A_SignalVector<
         return this.structure.includes(signalConstructor);
     }
 
-    get(signal: A_Signal): Record<string, any> | undefined
-    get(signalConstructor: A_TYPES__Component_Constructor<A_Signal>): Record<string, any> | undefined
-    get(param1: A_Signal | A_TYPES__Component_Constructor<A_Signal>): Record<string, any> | undefined {
-        let signalConstructor: A_TYPES__Component_Constructor<A_Signal>;
+    /**
+     * Retrieves the signal of the specified type from the vector.
+     * 
+     * @param signal 
+     */
+    get<T extends A_Signal>(signal: T): T | undefined
+    get<T extends A_Signal>(signalConstructor: A_TYPES__Entity_Constructor<T>): T | undefined
+    get<T extends A_Signal>(param1: T | A_TYPES__Entity_Constructor<T>): T | undefined {
+        let signalConstructor: A_TYPES__Entity_Constructor<A_Signal>;
 
         if (param1 instanceof A_Entity) {
-            signalConstructor = param1.constructor as A_TYPES__Component_Constructor<A_Signal>;
+            signalConstructor = param1.constructor as A_TYPES__Entity_Constructor<A_Signal>;
         } else {
-            signalConstructor = param1;
+            signalConstructor = param1 as A_TYPES__Entity_Constructor<A_Signal>;
         }
 
         const index = this._signals.findIndex(s => s.constructor === signalConstructor);
         if (index === -1) {
             return undefined;
         }
-        return this._signals[index];
+        return this._signals[index] as T;
     }
 
 
@@ -195,4 +241,3 @@ export class A_SignalVector<
         };
     }
 }
-

package/tests/A-Signal.test.ts

@@ -1,5 +1,5 @@
-import { A_Component, A_Concept, A_Container, A_Context, A_Feature, A_Inject, A_Scope } from "@adaas/a-concept";
-import { A_SignalBusFeatures, A_SignalFeatures } from "@adaas/a-utils/lib/A-Signal/A-Signal.constants";
+import { A_Caller, A_Component, A_Concept, A_Container, A_Context, A_Feature, A_Inject, A_Scope } from "@adaas/a-concept";
+import { A_SignalVectorFeatures } from "@adaas/a-utils/lib/A-Signal/A-Signal.constants";
 import { A_SignalBus } from "@adaas/a-utils/lib/A-Signal/components/A-SignalBus.component";
 import { A_SignalConfig } from "@adaas/a-utils/lib/A-Signal/context/A-SignalConfig.context";
 import { A_Signal } from "@adaas/a-utils/lib/A-Signal/entities/A-Signal.entity";
@@ -10,6 +10,60 @@ import { A_SignalVector } from "@adaas/a-utils/lib/A-Signal/entities/A-SignalVec
 jest.retryTimes(0);
 
 describe('A-Signal tests', () => {
+    it('Should Allow to create a new Signal', async () => {
+        const signal = new A_Signal<{ message: string }>({
+            data: {
+                message: 'Hello, World!'
+            }
+        });
+
+        expect(signal).toBeDefined();
+        expect(signal).toBeInstanceOf(A_Signal);
+        expect(signal.data.message).toBe('Hello, World!');
+    });
+    it('Should Allow to create a new Signal Vector', async () => {
+        class MySignalA extends A_Signal<{ buttonId: string }> { }
+        class MySignalB extends A_Signal<{ pageId: string }> { }
+
+        const vector = new A_SignalVector({
+            structure: [MySignalA, MySignalB],
+            values: [
+                new MySignalA({ data: { buttonId: 'submit-order' } }),
+                new MySignalB({ data: { pageId: 'home-page' } })
+            ]
+        });
+
+        expect(vector).toBeDefined();
+        expect(vector).toBeInstanceOf(A_SignalVector);
+        expect(vector.length).toBe(2);
+        expect((await vector.toDataVector())[0]?.buttonId).toBe('submit-order');
+        expect((await vector.toDataVector())[1]?.pageId).toBe('home-page');
+    });
+    it('Should Allow to get signals fro Signal Vector', async () => {
+        class MySignalA extends A_Signal<{ buttonId: string }> { }
+        class MySignalB extends A_Signal<{ pageId: string }> { }
+        class MySignalC extends A_Signal<{ userId: string }> { }
+
+        const vector = new A_SignalVector({
+            structure: [MySignalA, MySignalB],
+            values: [
+                new MySignalA({ data: { buttonId: 'submit-order' } }),
+                new MySignalB({ data: { pageId: 'home-page' } })
+            ]
+        });
+
+        const signalA = vector.get(MySignalA);
+        const signalB = vector.get(MySignalB);
+        const signalC = vector.get(MySignalC);
+
+        expect(signalA).toBeDefined();
+        expect(signalA).toBeInstanceOf(MySignalA);
+        expect(signalA?.data.buttonId).toBe('submit-order');
+        expect(signalB).toBeDefined();
+        expect(signalB).toBeInstanceOf(MySignalB);
+        expect(signalB?.data.pageId).toBe('home-page');
+        expect(signalC).toBeUndefined();
+    });
     it('Should Allow to emit basic signal structure', async () => {
 
         let result: A_SignalVector | undefined = undefined;
@@ -27,13 +81,13 @@ describe('A-Signal tests', () => {
                         buttonId: 'submit-order'
                     }
                 })
-                await signal.emit(scope)
+                await signal.next(scope)
             }
 
 
             @A_Feature.Extend()
-            async [A_SignalBusFeatures.Emit](
-                @A_Inject(A_SignalVector) vector: A_SignalVector
+            async [A_SignalVectorFeatures.Next](
+                @A_Inject(A_Caller) vector: A_SignalVector
             ) {
                 result = vector;
             }
@@ -91,13 +145,13 @@ describe('A-Signal tests', () => {
                     }
                 })
 
-                await signal.emit(scope)
+                await signal.next(scope)
             }
 
 
             @A_Feature.Extend()
-            async [A_SignalBusFeatures.Emit](
-                @A_Inject(A_SignalVector) vector: A_SignalVector
+            async [A_SignalVectorFeatures.Next](
+                @A_Inject(A_Caller) vector: A_SignalVector
             ) {
                 result = vector;
             }
@@ -130,4 +184,5 @@ describe('A-Signal tests', () => {
         expect((await result!.toDataVector())[2]).toBeUndefined();
 
     });
+
 })