@adaas/a-utils 0.1.30 → 0.1.32

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adaas/a-utils",
-  "version": "0.1.30",
+  "version": "0.1.32",
   "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-Memory/A-Memory.component.ts

@@ -64,10 +64,10 @@ export class A_Memory<
         context.clear();
     }
 
-    @A_Feature.Extend()
     /**
      * Handles the 'get' operation for retrieving a value from memory
      */
+    @A_Feature.Extend()
     async [A_MemoryFeatures.onGet](
         @A_Dependency.Required()
         @A_Inject(A_OperationContext) operation: A_MemoryOperationContext,

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

@@ -21,10 +21,12 @@ export type A_SignalConfig_Init = {
 
 
 export type A_SignalVector_Init<
-    TSignalData extends Record<string, any> = Record<string, any>
+    _TSignals extends Array<A_Signal> = Array<A_Signal>,
+    _TVectorStructure extends Array<A_TYPES__Entity_Constructor<_TSignals[number]>> = Array<A_TYPES__Entity_Constructor<_TSignals[number]>>
+
 > = {
-    structure: Array<A_TYPES__Entity_Constructor<A_Signal>>,
-    values: TSignalData[]
+    structure: _TVectorStructure,
+    values: _TSignals
 }
 
 
@@ -45,3 +47,10 @@ export type A_Signal_Init<T extends Record<string, any> = Record<string, any>> =
      */
     data: T
 }
+
+export type A_Signal_Serialized<T extends Record<string, any> = Record<string, any>> = {
+    /**
+     * The signal data
+     */
+    data: T
+} & A_TYPES__Entity_Serialized

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

@@ -32,12 +32,13 @@ export class A_SignalBus extends A_Component {
      * @param state 
      * @param config 
      * @returns 
-     */u
+     */
     @A_Feature.Extend({
         scope: [A_Signal]
     })
     async [A_SignalFeatures.Emit](
         @A_Inject(A_Caller) signal: A_Signal,
+        @A_Inject(A_Scope) scope: A_Scope,
 
         @A_Inject(A_Config) globalConfig?: A_Config<['A_SIGNAL_VECTOR_STRUCTURE']>,
         @A_Inject(A_Logger) logger?: A_Logger,
@@ -45,10 +46,18 @@ export class A_SignalBus extends A_Component {
         @A_Inject(A_SignalConfig) config?: A_SignalConfig,
     ) {
 
+        /*
+        1) create a signal when it occurs via new A_Signal('somedata')
+        2) emit a signal when needed via signal.emit(scope)
+        3) the bus should listen for all emitted signals within the scope
+        4) when a signal is emitted, the bus should store a signal in some place (probably it's memory)
+        */
+
         /**
          * We need a context where component is registered, to prevent any duplicate registrations
          */
-        const componentContext = A_Context.scope(this)
+        const componentContext = A_Context.scope(this);
+
 
         if (!config) {
             config = new A_SignalConfig({
@@ -66,16 +75,18 @@ export class A_SignalBus extends A_Component {
             componentContext.register(state);
         }
 
+
         if (!state.has(signal))
             return;
 
+
         //  ------------------------------------------------------------------
         //  And finally if all checks are passed, we can update the state
         //  ------------------------------------------------------------------
 
         logger?.debug(`A_SignalBus: Updating state for signal '${signal.constructor.name}' with data:`, signal.data);
 
-        state.set(signal, signal.data);
+        state.set(signal);
 
         const vector = state.toVector();
 
@@ -83,8 +94,7 @@ export class A_SignalBus extends A_Component {
             name: `A_SignalBus_Next_Scope_of_${this.constructor.name}`,
             entities: [vector]
         })
-            .inherit(A_Context.scope(this));
-
+            .inherit(scope);
 
         try {
 
@@ -99,5 +109,4 @@ export class A_SignalBus extends A_Component {
             throw error;
         }
     }
-
 }

package/src/lib/A-Signal/context/A-SignalConfig.context.ts

@@ -1,4 +1,4 @@
-import { A_Context, A_Fragment, A_TYPES__Component_Constructor, A_TYPES__Entity_Constructor } from "@adaas/a-concept";
+import { A_CommonHelper, A_Context, A_Fragment, A_TYPES__Component_Constructor, A_TYPES__Entity_Constructor } from "@adaas/a-concept";
 import { A_SignalConfig_Init } from "../A-Signal.types";
 import { A_Signal } from "../entities/A-Signal.entity";
 
@@ -25,12 +25,14 @@ export class A_SignalConfig extends A_Fragment {
         }
 
         const scope = A_Context.scope(this);
-        const signalConfigs = scope.allowedEntities;
 
         //  just sort by constructor name to have consistent order
-        return [...scope.allowedEntities]
-            .sort((a, b) => a.constructor.name.localeCompare(b.constructor.name))
-            .map(s => scope.resolveConstructor<A_Signal>(s.constructor.name));
+        const constructors = [...scope.allowedEntities]
+            .filter(e => A_CommonHelper.isInheritedFrom(e, A_Signal))
+            .sort((a, b) => a.constructor.name.localeCompare(b.name))
+            .map(s => scope.resolveConstructor<A_Signal>(s.name));
+
+        return constructors.filter(s => s) as Array<A_TYPES__Entity_Constructor<A_Signal>>;
     }
 
     /**

package/src/lib/A-Signal/context/A-SignalState.context.ts

@@ -24,7 +24,7 @@ export class A_SignalState<
      * Key: Signal constructor function
      * Value: Latest emitted data from that signal type
      */
-    protected _state: Map<A_TYPES__Component_Constructor<A_Signal>, TSignalData | undefined> = new Map();
+    protected _state: Map<A_TYPES__Component_Constructor<A_Signal>, A_Signal> = new Map();
 
     /**
      * Optional structure defining the ordered list of signal constructors
@@ -57,9 +57,7 @@ export class A_SignalState<
 
         // Initialize the state map with undefined values for each signal in the structure
         // This ensures all expected signals have entries in the state map from the start
-        this.structure.forEach((signalConstructor) => {
-            this._state.set(signalConstructor, undefined);
-        });
+      
     }
 
 
@@ -71,18 +69,21 @@ export class A_SignalState<
      */
     set(
         signal: A_Signal,
-        value: TSignalData
+        value: A_Signal
+    ): void
+    set(
+        signal: A_Signal
     ): void
     set(
         signal: A_TYPES__Component_Constructor<A_Signal>,
-        value: TSignalData
+        value: A_Signal
     ): void
     set(
         param1: A_TYPES__Component_Constructor<A_Signal> | A_Signal,
-        param2: TSignalData
+        param2?: A_Signal
     ): void {
         const signal = param1 instanceof A_Signal ? param1.constructor as A_TYPES__Component_Constructor<A_Signal> : param1;
-        const value = param2;
+        const value = param1 instanceof A_Signal ? param1 : param2!;
 
         this._state.set(signal, value);
     }
@@ -95,13 +96,13 @@ export class A_SignalState<
      */
     get(
         signal: A_Signal
-    ): TSignalData | undefined
+    ): A_Signal | undefined
     get(
         signal: A_TYPES__Component_Constructor<A_Signal>
-    ): TSignalData | undefined
+    ): A_Signal | undefined
     get(
         param: A_TYPES__Component_Constructor<A_Signal> | A_Signal
-    ): TSignalData | undefined {
+    ): A_Signal | undefined {
         const signal = param instanceof A_Signal ? param.constructor as A_TYPES__Component_Constructor<A_Signal> : param;
         return this._state.get(signal);
     }
@@ -122,6 +123,7 @@ export class A_SignalState<
         param: A_TYPES__Component_Constructor<A_Signal> | A_Signal
     ): boolean {
         const signal = param instanceof A_Signal ? param.constructor as A_TYPES__Component_Constructor<A_Signal> : param;
+
         return this.structure.includes(signal);
     }
 
@@ -155,13 +157,9 @@ export class A_SignalState<
      * @throws Error if structure is not defined or if any signal value is undefined
      */
     toVector(): A_SignalVector {
-        const vector: TSignalData[] = [];
+        const vector: Array<A_Signal> = [];
 
-        this.structure.forEach((signalConstructor) => {
-            const value = this._state.get(signalConstructor);
-            if (value === undefined) {
-                throw new Error(`Signal ${signalConstructor.name} has no value in state`);
-            }
+        this._state.forEach((value, key) => {
             vector.push(value);
         });
 
@@ -180,8 +178,8 @@ export class A_SignalState<
      * @returns Object mapping signal constructor names to their latest values
      * @throws Error if any signal value is undefined
      */
-    toObject(): Record<string, TSignalData> {
-        const obj: Record<string, TSignalData> = {};
+    toObject(): Record<string, A_Signal> {
+        const obj: Record<string, A_Signal> = {};
 
         this.structure.forEach((signalConstructor) => {
             const value = this._state.get(signalConstructor);

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

@@ -1,5 +1,5 @@
 import { A_Entity, A_Scope } from "@adaas/a-concept";
-import { A_Signal_Init } from "../A-Signal.types";
+import { A_Signal_Init, A_Signal_Serialized } from "../A-Signal.types";
 import { A_SignalFeatures } from "../A-Signal.constants";
 
 /**
@@ -15,14 +15,33 @@ import { A_SignalFeatures } from "../A-Signal.constants";
  * Signals are typically used in scenarios where the current state is more important than individual events, 
  * such as monitoring systems, real-time dashboards, or stateful applications.
  */
-export class A_Signal extends A_Entity<A_Signal_Init> {
+export class A_Signal<
+    _TSignalDataType extends Record<string, any> = Record<string, any>
+> extends A_Entity<A_Signal_Init<_TSignalDataType>, A_Signal_Serialized<_TSignalDataType>> {
 
-    data!: Record<string, any>;
+    data!: _TSignalDataType;
 
 
+    /**
+     * Allows to define default data for the signal.
+     * 
+     * If no data is provided during initialization, the default data will be used.
+     * 
+     * @returns 
+     */
+    static async default(): Promise<A_Signal | undefined> {
+        return undefined;
+    }
+
 
 
-    fromNew(newEntity: A_Signal_Init): void {
+    fromJSON(serializedEntity: A_Signal_Serialized<_TSignalDataType>): void {
+        super.fromJSON(serializedEntity);
+        this.data = serializedEntity.data;
+    }
+
+
+    fromNew(newEntity: A_Signal_Init<_TSignalDataType>): void {
         this.aseid = this.generateASEID({ entity: newEntity.name });
         this.data = newEntity.data;
     }
@@ -39,4 +58,12 @@ export class A_Signal extends A_Entity<A_Signal_Init> {
         await this.call(A_SignalFeatures.Emit, scope);
     }
 
+
+    toJSON(): A_Signal_Serialized<_TSignalDataType> {
+        return {
+            ...super.toJSON(),
+            data: this.data
+        };
+    }
+
 }

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

@@ -9,60 +9,174 @@ import { A_Signal } from "./A-Signal.entity";
  * 
  * Signal Vectors are useful in scenarios where multiple related signals need to be handled together,
  * as a state of the system or a snapshot of various parameters at a given time.
+ * 
+ * @template TSignalsConstructors - Array of signal constructor types (e.g., [typeof MySignal, typeof CustomSignal])
+ * @template TSignals - Array of signal instances derived from constructors
  */
-export class A_SignalVector extends A_Entity<A_SignalVector_Init, A_SignalVector_Serialized> {
+export class A_SignalVector<
+    TSignals extends Array<A_Signal> = Array<A_Signal>,
+    TSignalsConstructors extends Array<A_TYPES__Entity_Constructor<A_Signal>> = TSignals extends Array<infer U> ? U extends A_Signal ? A_TYPES__Entity_Constructor<U>[] : never : never
+> extends A_Entity<A_SignalVector_Init<TSignals[number][], TSignalsConstructors>, A_SignalVector_Serialized> {
 
     /**
      * The structure of the signal vector, defining the types of signals it contains.
      * 
      * For example:
      * [UserSignInSignal, UserStatusSignal, UserActivitySignal]
+     * 
+     * [!] if not provided, it will be derived from the signals values.
      */
-    structure!: Array<A_TYPES__Entity_Constructor<A_Signal>>;
+    protected _structure?: TSignalsConstructors;
     /**
-     * The values of the signals in the vector.
-     * Each entry corresponds to the data of a signal in the structure.
+     * It's actual vector Values of Signals like :
+     * [UserActionSignal, UserMousePositionSignal, ExternalDependencySignal]
+     */
+    protected _signals!: TSignals[number][]
+
+
+    fromNew(newEntity: A_SignalVector_Init<TSignals[number][], TSignalsConstructors>): void {
+        super.fromNew(newEntity);
+        this._structure = newEntity.structure;
+        this._signals = newEntity.values;
+    }
+
+    /**
+     * The structure of the signal vector, defining the types of signals it contains.
      * 
      * For example:
-     * [
-     *   { userId: '123', timestamp: '2023-10-01T12:00:00Z' }, // UserSignInSignal data
-     *   { userId: '123', status: 'online' },                 // UserStatusSignal data
-     *   { userId: '123', activity: 'browsing' }              // UserActivitySignal data
-     * ]
+     * [UserSignInSignal, UserStatusSignal, UserActivitySignal]
      * 
+     */
+    get structure(): TSignalsConstructors {
+        return this._structure || this._signals.map(s => s.constructor as A_TYPES__Entity_Constructor<A_Signal>) as TSignalsConstructors;
+    }
+
+
+    get length(): number {
+        return this.structure.length;
+    }
+
+
+    /**
+     * Checks if the vector contains a signal of the specified type.
      * 
-     * [!] For further processing it's recommended to convert any objects to plain text
+     * @param signal 
      */
-    values!: Array<Record<string, any>>;
+    has(signal: A_Signal): boolean
+    has(signalConstructor: A_TYPES__Component_Constructor<A_Signal>): boolean
+    has(param1: A_Signal | A_TYPES__Component_Constructor<A_Signal>): boolean {
+        let signalConstructor: A_TYPES__Component_Constructor<A_Signal>;
+        if (param1 instanceof A_Entity) {
+            signalConstructor = param1.constructor as A_TYPES__Component_Constructor<A_Signal>;
+        } else {
+            signalConstructor = param1;
+        }
+        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>;
 
-    fromNew(newEntity: A_SignalVector_Init): void {
-        super.fromNew(newEntity);
-        this.structure = newEntity.structure;
-        this.values = newEntity.values;
+        if (param1 instanceof A_Entity) {
+            signalConstructor = param1.constructor as A_TYPES__Component_Constructor<A_Signal>;
+        } else {
+            signalConstructor = param1;
+        }
+
+        const index = this._signals.findIndex(s => s.constructor === signalConstructor);
+        if (index === -1) {
+            return undefined;
+        }
+        return this._signals[index];
     }
 
 
     /**
      * Converts to Array of values of signals in the vector
+     * Maintains the order specified in the structure/generic type
      * 
-     * @returns 
+     * @param structure - Optional structure to override the default ordering
+     * @returns Array of signal instances in the specified order
      */
-    toVector(): Array<Record<string, any>> {
-        return this.values;
+    async toVector<
+        T extends Array<A_Signal> = TSignals,
+    >(
+        structure?: { [K in keyof T]: T[K] extends A_Signal ? A_TYPES__Entity_Constructor<T[K]> : never }
+    ): Promise<{ [K in keyof T]: T[K] }> {
+        const usedStructure = structure || this.structure;
+
+        return usedStructure.map((signalConstructor) => {
+            const signalIndex = this._signals.findIndex(s => s.constructor === signalConstructor);
+            return signalIndex !== -1 ? this._signals[signalIndex] : undefined;
+        }) as { [K in keyof T]: T[K] };
     }
 
+
     /**
-     * Converts to Object with signal names as keys and their corresponding values
+     * Converts to Array of data of signals in the vector
+     * Maintains the order specified in the structure/generic type
      * 
-     * @returns 
+     * @param structure - Optional structure to override the default ordering
+     * @returns Array of serialized signal data in the specified order
+     */
+    async toDataVector<
+        T extends Array<A_Signal> = TSignals,
+    >(
+        structure?: { [K in keyof T]: T[K] extends A_Signal ? A_TYPES__Entity_Constructor<T[K]> : never }
+    ): Promise<{ [K in keyof T]: T[K] extends A_Signal<infer D> ? D | undefined : never }> {
+
+        const usedStructure = structure || this.structure;
+
+        const results: Array<any> = [];
+
+        for (const signalConstructor of usedStructure) {
+            const signalIndex = this._signals.findIndex(s => s.constructor === signalConstructor);
+            let data: any;
+            if (signalIndex === -1) {
+
+                data = await (signalConstructor as typeof A_Signal).default()
+
+            } else {
+                const signal = this._signals[signalIndex];
+                data = signal;
+            }
+
+
+            results.push(data?.toJSON().data);
+        }
+
+        return results as { [K in keyof T]: T[K] extends A_Signal<infer D> ? D | undefined : never };
+    }
+
+    /**
+     * Converts to Object with signal constructor names as keys and their corresponding data values
+     * Uses the structure ordering to ensure consistent key ordering
+     * 
+     * @returns Object with signal constructor names as keys and signal data as values
      */
-    toObject(): Record<string, any> {
-        const obj: Record<string, any> = {};
-        this.structure.forEach((signalConstructor, index) => {
+    async toObject<
+        T extends Array<A_Signal> = TSignals,
+    >(
+        structure?: { [K in keyof T]: T[K] extends A_Signal ? A_TYPES__Entity_Constructor<T[K]> : never }
+    ): Promise<{ [key: string]: T[number] extends A_Signal<infer D> ? D | undefined : never }> {
+
+        const usedStructure = structure || this.structure;
+
+        const obj: { [key: string]: T[number] extends A_Signal<infer D> ? D | undefined : never } = {};
+        usedStructure.forEach((signalConstructor) => {
             const signalName = signalConstructor.name;
-            obj[signalName] = this.values[index];
+            const signalIndex = this._signals.findIndex(s => s.constructor === signalConstructor);
+
+            if (signalIndex !== -1) {
+                const signal = this._signals[signalIndex];
+                obj[signalName] = signal.toJSON().data as any;
+            } else {
+                obj[signalName] = undefined as any;
+            }
         });
+
         return obj;
     }
 
@@ -77,7 +191,8 @@ export class A_SignalVector extends A_Entity<A_SignalVector_Init, A_SignalVector
         return {
             ...super.toJSON(),
             structure: this.structure.map(s => s.name),
-            values: this.values
+            values: this._signals.map(s => s.toJSON())
         };
     }
-}
+}
+

package/tests/A-Signal.test.ts

@@ -10,9 +10,9 @@ 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 config object', async () => {
+    it('Should Allow to emit basic signal structure', async () => {
 
-        let result;
+        let result: A_SignalVector | undefined = undefined;
 
         class UserIntentionListener extends A_Component {
             @A_Concept.Start()
@@ -27,8 +27,69 @@ describe('A-Signal tests', () => {
                         buttonId: 'submit-order'
                     }
                 })
+                await signal.emit(scope)
+            }
+
+
+            @A_Feature.Extend()
+            async [A_SignalBusFeatures.Emit](
+                @A_Inject(A_SignalVector) vector: A_SignalVector
+            ) {
+                result = vector;
+            }
+        }
+
+        const concept = new A_Concept({
+            name: 'test-concept',
+            containers: [new A_Container({
+                name: 'test-container',
+                components: [A_SignalBus, UserIntentionListener],
+                fragments: [
+                    new A_SignalConfig({
+                        structure: [A_Signal]
+                    })
+                ]
+            })]
+        });
+
+        await concept.load();
+        await concept.start();
+
+        expect(result).toBeDefined();
+        expect(result).toBeInstanceOf(A_SignalVector);
+        expect(result!.length).toBe(1);
+        expect((await result!.toDataVector())[0]?.buttonId).toBe('submit-order');
+
+    });
+    it('Should Allow to work with custom Signals', async () => {
+
+        class UserIntentionSignal extends A_Signal<{ buttonId: string }> { }
+
+        class UserMousePositionSignal extends A_Signal<{ x: number, y: number }> {
+            static async default(): Promise<A_Signal | undefined> {
+                return Promise.resolve(new UserMousePositionSignal({
+                    data: { x: 0, y: 0 }
+                }));
+            }
+        }
+        class UserElementHoverSignal extends A_Signal<{ elementId: string }> { }
+
+
+
+        let result: A_SignalVector | undefined = undefined;
+
+        class UserIntentionListener extends A_Component {
+            @A_Concept.Start()
+            async start(
+                @A_Inject(A_Scope) scope: A_Scope,
+                @A_Inject(A_SignalBus) bus: A_SignalBus
+            ) {
 
-                console.log(A_Context.featureTemplate(A_SignalFeatures.Emit, signal, scope))
+                const signal = new UserIntentionSignal({
+                    data: {
+                        buttonId: 'submit-order'
+                    }
+                })
 
                 await signal.emit(scope)
             }
@@ -49,7 +110,7 @@ describe('A-Signal tests', () => {
                 components: [A_SignalBus, UserIntentionListener],
                 fragments: [
                     new A_SignalConfig({
-                        structure: [A_Signal]
+                        structure: [UserIntentionSignal, UserMousePositionSignal, UserElementHoverSignal]
                     })
                 ]
             })]
@@ -58,9 +119,15 @@ describe('A-Signal tests', () => {
         await concept.load();
         await concept.start();
 
+
         expect(result).toBeDefined();
-        expect(result.values.length).toBe(1);
-        expect(result.values[0].buttonId).toBe('submit-order');
+        expect(result).toBeInstanceOf(A_SignalVector);
+        expect(result!.length).toBe(3);
+
+        expect((await result!.toDataVector())[0]?.buttonId).toBe('submit-order');
+        expect((await result!.toDataVector())[1]?.x).toBe(0);
+        expect((await result!.toDataVector())[1]?.y).toBe(0);
+        expect((await result!.toDataVector())[2]).toBeUndefined();
 
     });
 })