@adaas/a-utils 0.2.5 → 0.2.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adaas/a-utils",
-  "version": "0.2.5",
+  "version": "0.2.7",
   "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",
@@ -80,8 +80,8 @@
     "build": "tsup --config tsup.config.ts"
   },
   "dependencies": {
-    "@adaas/a-concept": "^0.2.5",
-    "@adaas/a-frame": "^0.0.7"
+    "@adaas/a-concept": "^0.2.7",
+    "@adaas/a-frame": "^0.0.8"
   },
   "devDependencies": {
     "@types/chai": "^4.3.14",

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

@@ -2,13 +2,13 @@ import { A_TYPES__Component_Constructor, A_TYPES__Entity_Constructor, A_TYPES__E
 import { A_Signal } from "./entities/A-Signal.entity"
 
 
-export type A_SignalConfig_Init = {
+export type A_SignalConfig_Init<TSignals extends Array<A_Signal> = Array<A_Signal>> = {
     /**
      * An array defining the structure of the signal vector.
      * 
      * Each entry corresponds to a signal component constructor.
      */
-    structure?: Array<A_TYPES__Entity_Constructor<A_Signal>>
+    structure?: A_Signal_TSignalsConstructors<TSignals>
     /**
      * A string representation of the structure for easier DI resolution.
      * Each signal's constructor name is used to form this string.
@@ -21,14 +21,25 @@ export type A_SignalConfig_Init = {
     propagateSignals?: boolean
 }
 
+// export type A_Signal_TSignalsConstructors<T extends Array<A_Signal> = Array<A_Signal>> = {
+//     [K in keyof T]: T[K] extends A_Signal ? A_TYPES__Entity_Constructor<T[K]> : never
+// }
+
+export type A_Signal_TSignalsConstructors<T extends Array<A_Signal> = Array<A_Signal>> = T extends Array<infer U> ? U extends A_Signal ? A_TYPES__Entity_Constructor<U>[] : never : never
+
+
+export type A_SignalTValue<T extends A_Signal> = T extends A_Signal<infer U> ? U : never;
+
+export type A_SignalTValueArray<T extends Array<A_Signal>> = {
+    [K in keyof T]: T[K] extends A_Signal<infer U> ? U : never
+}
 
 
 export type A_SignalVector_Init<
     _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: _TVectorStructure,
+    structure: A_Signal_TSignalsConstructors<_TSignals>,
     values: _TSignals
 }
 
@@ -41,6 +52,12 @@ export type A_SignalVector_Serialized = A_TYPES__Entity_Serialized & {
 
 
 export type A_Signal_Init<T extends Record<string, any> = Record<string, any>> = {
+    /**
+     * Possible signal id
+     * 
+     * [!] used for identification only, all properties will be participating in the hash calculation for deduplication
+     */
+    id?: Array<any>,
     /**
      * The signal name
      */

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

@@ -195,10 +195,7 @@ export class A_SignalState<
             vector.push(value);
         });
 
-        return new A_SignalVector({
-            structure: this.structure,
-            values: vector
-        });
+        return new A_SignalVector(vector, this.structure);
     }
 
     /**

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

@@ -24,9 +24,10 @@ export class A_Signal<
     _TSignalDataType extends Record<string, any> = Record<string, any>
 > extends A_Entity<A_Signal_Init<_TSignalDataType>, A_Signal_Serialized<_TSignalDataType>> {
 
-    data!: _TSignalDataType;
-
 
+    // ========================================================================
+    // ========================== Static Methods ==============================
+    // ========================================================================
     /**
      * Allows to define default data for the signal.
      * 
@@ -38,6 +39,99 @@ export class A_Signal<
         return undefined;
     }
 
+    // ========================================================================
+    // ========================== Instance Properties ========================
+    // ========================================================================
+
+    /**
+     * The actual data carried by the signal.
+     */
+    data!: _TSignalDataType;
+
+    /**
+      * Generates signal hash uses for comparison
+      * 
+      * @param str 
+      */
+    protected createHash(str?: string): string
+    protected createHash(str?: undefined): string
+    protected createHash(str?: Record<string, any>): string
+    protected createHash(str?: Array<any>): string
+    protected createHash(str?: number): string
+    protected createHash(str?: boolean): string
+    protected createHash(str?: null): string
+    protected createHash(map?: Map<any, any>): string
+    protected createHash(set?: Set<any>): string
+    protected createHash(str?: any): string {
+        let hashSource: string;
+
+        if (str instanceof Map) {
+            hashSource = JSON.stringify(Array.from(str.entries()));
+        } else if (str instanceof Set) {
+            hashSource = JSON.stringify(Array.from(str.values()));
+        } else {
+            switch (typeof str) {
+                case 'string':
+                    hashSource = str;
+                    break;
+                case 'undefined':
+                    hashSource = 'undefined';
+                    break;
+
+                case 'object':
+                    if ('toJSON' in str)
+                        hashSource = JSON.stringify(str.toJSON());
+
+                    else
+                        hashSource = JSON.stringify(str);
+                    break;
+                case 'number':
+                    hashSource = str.toString();
+                    break;
+                case 'boolean':
+                    hashSource = str ? 'true' : 'false';
+                    break;
+                case 'function':
+                    hashSource = str.toString();
+                    break;
+                default:
+                    hashSource = String(str);
+            }
+        }
+
+        let hash = 0, i, chr;
+        for (i = 0; i < hashSource.length; i++) {
+            chr = hashSource.charCodeAt(i);
+            hash = ((hash << 5) - hash) + chr;
+            hash |= 0; // Convert to 32bit integer
+        }
+
+        const hashString = hash.toString();
+
+        return hashString;
+    }
+
+    /**
+     * This method compares the current signal with another signal instance by deduplication ID
+     * this id can be configured during initialization with the "id" property.
+     * 
+     * example: 
+     * * const signalA = new A_Signal({ id: ['user-status', 'user123'], data: { status: 'online' } });
+     * * const signalB = new A_Signal({ id: ['user-status', 'user123'], data: { status: 'offline' } });
+     * 
+     * signalA.compare(signalB) // true because both signals have the same deduplication ID
+     * 
+     * @param other 
+     * @returns 
+     */
+    compare(other: A_Signal<_TSignalDataType>): boolean {
+        if (this.aseid.id !== other.aseid.id) {
+            return false;
+        }
+
+        return true;
+    }
+    
 
 
     fromJSON(serializedEntity: A_Signal_Serialized<_TSignalDataType>): void {
@@ -47,10 +141,20 @@ export class A_Signal<
 
 
     fromNew(newEntity: A_Signal_Init<_TSignalDataType>): void {
-        this.aseid = this.generateASEID({ entity: newEntity.name });
         this.data = newEntity.data;
-    }
 
+        const identity = newEntity.id || {
+            name: newEntity.name,
+            data: this.data
+        };
+
+        const id = this.createHash(identity);
+
+        this.aseid = this.generateASEID({
+            entity: newEntity.name,
+            id: id,
+        });
+    }
 
 
     toJSON(): A_Signal_Serialized<_TSignalDataType> {

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

@@ -1,5 +1,5 @@
 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_SignalVector_Serialized, A_SignalVector_Init, A_Signal_TSignalsConstructors, A_SignalTValue, A_SignalTValueArray } from "../A-Signal.types";
 import { A_Signal } from "./A-Signal.entity";
 import { A_Frame } from "@adaas/a-frame";
 
@@ -20,9 +20,8 @@ import { A_Frame } from "@adaas/a-frame";
     description: 'A Signal Vector Entity represents a collection of signals structured in a specific way, allowing for batch processing and transmission of related signals as a unified state representation.'
 })
 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> {
+    TSignals extends A_Signal[] = A_Signal[],
+> extends A_Entity<A_SignalVector_Init<TSignals>> {
 
     /**
      * The structure of the signal vector, defining the types of signals it contains.
@@ -32,15 +31,31 @@ export class A_SignalVector<
      * 
      * [!] if not provided, it will be derived from the signals values.
      */
-    protected _structure?: TSignalsConstructors;
+    protected _structure?: A_Signal_TSignalsConstructors<TSignals>;
     /**
      * It's actual vector Values of Signals like :
      * [UserActionSignal, UserMousePositionSignal, ExternalDependencySignal]
      */
-    protected _signals!: TSignals[number][]
+    protected _signals!: TSignals
 
+    constructor(values: TSignals, structure?: { [K in keyof TSignals]: TSignals[K] extends A_Signal ? A_TYPES__Entity_Constructor<TSignals[K]> : never })
+    constructor(serialized: A_SignalVector_Serialized)
+    constructor(param1: TSignals | A_SignalVector_Serialized, param2?: A_Signal_TSignalsConstructors<TSignals>) {
 
-    fromNew(newEntity: A_SignalVector_Init<TSignals[number][], TSignalsConstructors>): void {
+        if ('aseid' in param1) {
+            // Handle serialized case
+            super(param1 as A_SignalVector_Serialized);
+        } else {
+            // Handle init case  
+            super({
+                structure: param2 ? param2 : (param1 as TSignals).map(s => s.constructor as A_TYPES__Entity_Constructor<TSignals[number]>) as A_Signal_TSignalsConstructors<TSignals>,
+                values: param1 as TSignals
+            } as A_SignalVector_Init<TSignals>);
+        }
+    }
+
+
+    fromNew(newEntity: A_SignalVector_Init<TSignals>): void {
         super.fromNew(newEntity);
         this._structure = newEntity.structure;
         this._signals = newEntity.values;
@@ -53,8 +68,8 @@ export class A_SignalVector<
      * [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 structure(): A_Signal_TSignalsConstructors<TSignals> {
+        return this._structure || this._signals.map(s => s.constructor as A_TYPES__Entity_Constructor<TSignals[number]>) as A_Signal_TSignalsConstructors<TSignals>;
     }
 
 
@@ -93,22 +108,75 @@ export class A_SignalVector<
     }
 
 
+    /**
+     * Allows to match the current Signal Vector with another Signal Vector by comparing each signal in the structure.
+     * This method returns true if all signals in the vector match the corresponding signals in the other vector.
+     * 
+     * @param other 
+     * @returns 
+     */
+    match(other: A_SignalVector<TSignals>): boolean {
+        if (this.length !== other.length) {
+            return false;
+        }
+
+        for (let i = 0; i < this.length; i++) {
+            const thisSignalConstructor = this.structure[i];
+            const otherSignalConstructor = other.structure[i];
+
+            if (thisSignalConstructor !== otherSignalConstructor) {
+                return false;
+            }
+
+            const thisSignalIndex = this._signals.findIndex(s => s.constructor === thisSignalConstructor);
+            const otherSignalIndex = other._signals.findIndex(s => s.constructor === otherSignalConstructor);
+
+            const thisSignal = thisSignalIndex !== -1 ? this._signals[thisSignalIndex] : undefined;
+            const otherSignal = otherSignalIndex !== -1 ? other._signals[otherSignalIndex] : undefined;
+
+            if (thisSignal && otherSignal) {
+                if (!thisSignal.compare(otherSignal)) {
+                    return false;
+                }
+            } else if (thisSignal || otherSignal) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
     
+    /**
+     * This method should ensure that the current Signal Vector contains all signals from the provided Signal Vector.
+     * 
+     * @param signal 
+     */
+    contains(signal: A_SignalVector): boolean{
+        for (const signalConstructor of signal.structure) {
+            const signalIndex = this._signals.findIndex(s => s.constructor === signalConstructor);
+            if (signalIndex === -1) {
+                return false;
+            }
+        }
+        return true;
+    }
+
     /**
      * Checks if the vector contains a signal of the specified type.
      * 
      * @param signal 
      */
     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>;
+    has(signalConstructor: A_TYPES__Entity_Constructor<A_Signal>): boolean
+    has(param1: A_Signal | A_TYPES__Entity_Constructor<A_Signal>): boolean {
+        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;
         }
-        return this.structure.includes(signalConstructor);
+        return this.structure.includes(signalConstructor as any);
     }
 
     /**
@@ -145,14 +213,14 @@ export class A_SignalVector<
     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] }> {
+        structure?: A_Signal_TSignalsConstructors<T>
+    ): Promise<T> {
         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] };
+        }) as T;
     }
 
 
@@ -164,10 +232,10 @@ export class A_SignalVector<
      * @returns Array of serialized signal data in the specified order
      */
     async toDataVector<
-        T extends Array<A_Signal> = TSignals,
+        T extends 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 }> {
+        structure?: A_Signal_TSignalsConstructors<T>
+    ): Promise<A_SignalTValueArray<T>> {
 
         const usedStructure = structure || this.structure;
 
@@ -189,7 +257,7 @@ export class A_SignalVector<
             results.push(data?.toJSON().data);
         }
 
-        return results as { [K in keyof T]: T[K] extends A_Signal<infer D> ? D | undefined : never };
+        return results as A_SignalTValueArray<T>;
     }
 
     /**

package/src/lib/A-StateMachine/A-StateMachine.component.ts

@@ -61,7 +61,23 @@ export class A_StateMachine<
      */
     get ready(): Promise<void> {
         if (!this._initialized) {
-            this._initialized = this.call(A_StateMachineFeatures.onInitialize);
+            this._initialized = new Promise<void>(
+                async (resolve, reject) => {
+                    try {
+                        await this.call(A_StateMachineFeatures.onInitialize);
+
+                        resolve();
+                    } catch (error) {
+                        const wrappedError = new A_StateMachineError({
+                            title: A_StateMachineError.InitializationError,
+                            description: `An error occurred during state machine initialization.`,
+                            originalError: error
+                        });
+
+                        reject(wrappedError);
+                    }
+                }
+            );
         }
 
         return this._initialized;

package/tests/A-Signal.test.ts

@@ -25,13 +25,10 @@ describe('A-Signal tests', () => {
         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' } })
-            ]
-        });
+        const vector = new A_SignalVector<[MySignalA, MySignalB]>([
+            new MySignalA({ data: { buttonId: 'submit-order' } }),
+            new MySignalB({ data: { pageId: 'home-page' } })
+        ]);
 
         expect(vector).toBeDefined();
         expect(vector).toBeInstanceOf(A_SignalVector);
@@ -39,18 +36,59 @@ describe('A-Signal tests', () => {
         expect((await vector.toDataVector())[0]?.buttonId).toBe('submit-order');
         expect((await vector.toDataVector())[1]?.pageId).toBe('home-page');
     });
+    it('Should Allow to match Signal Vector', async () => {
+        class MySignalA extends A_Signal<{ buttonId: string }> { }
+        class MySignalB extends A_Signal<{ pageId: string }> { }
+
+        const vector = new A_SignalVector<[MySignalA, MySignalB]>([
+            new MySignalA({ data: { buttonId: 'submit-order' } }),
+            new MySignalB({ data: { pageId: 'home-page' } })
+        ]);
+        const vector2 = new A_SignalVector<[MySignalA, MySignalB]>([
+            new MySignalA({ data: { buttonId: 'submit-order2' } }),
+            new MySignalB({ data: { pageId: 'home-page' } })
+        ]);
+        const vector3 = new A_SignalVector<[MySignalA, MySignalB]>([
+            new MySignalA({ data: { buttonId: 'submit-order' } }),
+            new MySignalB({ data: { pageId: 'home-page' } })
+        ]);
+
+        expect(vector.match(vector2)).toBe(false);
+        expect(vector.match(vector3)).toBe(true);
+    });
+    it('Should Allow to check if Signal Vector contains another 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<[MySignalA, MySignalB, MySignalC]>([
+            new MySignalA({ data: { buttonId: 'submit-order' } }),
+            new MySignalB({ data: { pageId: 'home-page' } }),
+            new MySignalC({ data: { userId: 'user123' } })
+        ]);
+        const vector2 = new A_SignalVector<[MySignalA, MySignalC]>([
+            new MySignalA({ data: { buttonId: 'submit-order' } }),
+            new MySignalC({ data: { userId: 'user123' } })
+        ]);
+        const vector3 = new A_SignalVector<[MySignalB]>([
+            new MySignalB({ data: { pageId: 'other-page' } })
+        ]);
+
+        expect(vector.contains(vector2)).toBe(true);
+        expect(vector.contains(vector3)).toBe(true);
+        expect(vector2.contains(vector)).toBe(false);
+
+    });
     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 vector = new A_SignalVector([
+            new MySignalA({ data: { buttonId: 'submit-order' } }),
+            new MySignalB({ data: { pageId: 'home-page' } })
+        ]);
 
         const signalA = vector.get(MySignalA);
         const signalB = vector.get(MySignalB);