@adaas/a-utils 0.3.5 → 0.3.7

package/src/helpers/A-Utils.helper.ts

@@ -0,0 +1,186 @@
+import { A_Caller, A_Component, A_Feature, A_Inject } from "@adaas/a-concept";
+import { A_Frame } from "@adaas/a-frame";
+import { A_ExecutionContext } from "@adaas/a-utils/a-execution";
+
+
+
+@A_Frame.Component({
+    namespace: 'A-Utils',
+    name: 'A-UtilsHelper',
+    description: 'Utility helper class providing common functions for A-Utils library, such as hashing and serialization.'
+})
+export class A_UtilsHelper extends A_Component {
+
+    // ─────────────────────────────────────────────────────────────────────────────
+    // ── Hashing ──────────────────────────────────────────────────────────────────
+    // ─────────────────────────────────────────────────────────────────────────────
+
+    /**
+     * Produces a deterministic, collision-resistant hash string for any JS value.
+     * 
+     * Improvements over the legacy `createHash`:
+     *  - **Null-safe** — handles `null` without throwing  
+     *  - **Function-aware serialization** — functions inside objects / arrays are
+     *    serialized via `.toString()` so `{ fn: () => 1 }` ≠ `{}`  
+     *  - **FNV-1a 52-bit** — better avalanche / distribution than DJB2-32,
+     *    and uses the safe JS integer range so the result is always positive  
+     *  - **Hex output** — compact, URL-safe, fixed-width (13 chars)
+     * 
+     * @param value  Any value: string, number, boolean, null, undefined,
+     *               object, array, Map, Set, function, or a mix of these.
+     * @returns      A 13-character lower-hex string (52-bit FNV-1a).
+     */
+    static hash(value?: any): string {
+        const source = A_UtilsHelper.serialize(value);
+        return A_UtilsHelper.fnv1a52(source);
+    }
+
+
+    // ─────────────────────────────────────────────────────────────────────────────
+    // ── Serialization ────────────────────────────────────────────────────────────
+    // ─────────────────────────────────────────────────────────────────────────────
+
+    /**
+     * Converts any JS value into a deterministic string representation
+     * suitable for hashing.
+     * 
+     * Key properties:
+     *  - **Deterministic**: same logical value → same string every time
+     *  - **Injective-ish**: structurally different values produce different
+     *    strings (type tags prevent `"3"` vs `3` collisions)
+     *  - **Recursive**: handles nested objects, arrays, Maps, Sets
+     *  - **Function-aware**: serializes functions via `.toString()`
+     * 
+     * @param value  Anything.
+     * @returns      A deterministic string.
+     */
+    static serialize(value: any): string {
+        // Primitives & null/undefined
+        if (value === null) return '<null>';
+        if (value === undefined) return '<undefined>';
+
+        switch (typeof value) {
+            case 'string':
+                return `s:${value}`;
+            case 'number':
+                return `n:${value}`;
+            case 'boolean':
+                return `b:${value}`;
+            case 'bigint':
+                return `bi:${value}`;
+            case 'symbol':
+                return `sym:${value.toString()}`;
+            case 'function':
+                return `fn:${value.toString()}`;
+        }
+
+        // Map
+        if (value instanceof Map) {
+            const entries = Array.from(value.entries())
+                .map(([k, v]) => `${A_UtilsHelper.serialize(k)}=>${A_UtilsHelper.serialize(v)}`)
+                .sort()
+                .join(',');
+            return `Map{${entries}}`;
+        }
+
+        // Set
+        if (value instanceof Set) {
+            const items = Array.from(value.values())
+                .map(v => A_UtilsHelper.serialize(v))
+                .sort()
+                .join(',');
+            return `Set{${items}}`;
+        }
+
+        // Date
+        if (value instanceof Date) {
+            return `Date:${value.toISOString()}`;
+        }
+
+        // RegExp
+        if (value instanceof RegExp) {
+            return `RegExp:${value.toString()}`;
+        }
+
+        // Array
+        if (Array.isArray(value)) {
+            const items = value.map(v => A_UtilsHelper.serialize(v)).join(',');
+            return `[${items}]`;
+        }
+
+        // toJSON support (e.g. custom entities, ASEID, etc.)
+        if (typeof value.toJSON === 'function') {
+            return `json:${A_UtilsHelper.serialize(value.toJSON())}`;
+        }
+
+        // Plain object — sort keys for determinism, serialize functions too
+        const keys = Object.keys(value).sort();
+        const pairs = keys.map(k => `${k}:${A_UtilsHelper.serialize(value[k])}`).join(',');
+        return `{${pairs}}`;
+    }
+
+
+    // ─────────────────────────────────────────────────────────────────────────────
+    // ── FNV-1a (pure Number, no BigInt) ──────────────────────────────────────────
+    // ─────────────────────────────────────────────────────────────────────────────
+
+    /**
+     * FNV-1a hash using two 32-bit halves to simulate a 52-bit space,
+     * without requiring BigInt.
+     * 
+     * Works identically in:
+     *  - All browsers (including Safari 13, IE11 polyfill targets, React Native)
+     *  - Node.js (any version)
+     *  - Web Workers, Service Workers, Deno, Bun
+     * 
+     * - Better avalanche than DJB2 (each input bit affects many output bits)
+     * - ~52-bit effective space — vastly fewer collisions than 32-bit
+     * - Always produces a **positive** hex string of 13 characters
+     * 
+     * @param input  Pre-serialized string.
+     * @returns      13-character lower-hex string.
+     */
+    private static fnv1a52(input: string): string {
+        // FNV-1a offset basis split into two 32-bit halves
+        let h1 = 0x811c9dc5;  // low 32 bits
+        let h2 = 0x00000842;  // high 20 bits (keeps us in 52-bit range)
+
+        // FNV prime = 0x01000193
+        const PRIME = 0x01000193;
+
+        for (let i = 0; i < input.length; i++) {
+            h1 ^= input.charCodeAt(i);
+
+            // Multiply h1 by prime (32-bit, unsigned)
+            const product = Math.imul(h1, PRIME);
+            h1 = product >>> 0;
+
+            // Carry overflow into h2, keep h2 within 20 bits
+            h2 = ((Math.imul(h2, PRIME) + (product / 0x100000000 >>> 0)) & 0xFFFFF) >>> 0;
+        }
+
+        // Combine: h2 (20 bits) << 32 | h1 (32 bits) → 52-bit number
+        // Since 2^52 fits in Number.MAX_SAFE_INTEGER, this is exact.
+        const combined = h2 * 0x100000000 + h1;
+
+        return combined.toString(16).padStart(13, '0');
+    }
+
+
+
+    // ==============================================================================
+    // =============== Instance methods for used for Injection ======================
+    // ==============================================================================
+    @A_Frame.Method({
+        description: 'Instance method wrapper for the static hash function, allowing it to be injected as a dependency.'
+    })
+    hash(
+        @A_Inject(A_Caller) caller: any,
+        @A_Inject(A_ExecutionContext) context: A_ExecutionContext,
+        @A_Inject(A_Feature) feature: A_Feature
+    ) {
+        const hash = A_UtilsHelper.hash(caller);
+
+        context.set(feature.name, hash);
+    }
+}

package/src/helpers/index.ts

@@ -0,0 +1 @@
+export { A_UtilsHelper } from './A-Utils.helper';

package/src/lib/A-Service/A-Service.container.ts

@@ -26,11 +26,11 @@ export class A_Service extends A_Container {
      */
     async load() {
         try {
-            await this.call(A_ServiceFeatures.onBeforeLoad);
+            await this.call(A_ServiceFeatures.onBeforeLoad, this.scope);
 
-            await this.call(A_ServiceFeatures.onLoad);
+            await this.call(A_ServiceFeatures.onLoad, this.scope);
 
-            await this.call(A_ServiceFeatures.onAfterLoad);
+            await this.call(A_ServiceFeatures.onAfterLoad, this.scope);
 
         } catch (error) {
 
@@ -56,7 +56,7 @@ export class A_Service extends A_Container {
 
             this.scope.register(wrappedError);
 
-            await this.call(A_ServiceFeatures.onError);
+            await this.call(A_ServiceFeatures.onError, this.scope);
         }
 
     }
@@ -68,11 +68,11 @@ export class A_Service extends A_Container {
      */
     async start() {
         try {
-            await this.call(A_ServiceFeatures.onBeforeStart);
+            await this.call(A_ServiceFeatures.onBeforeStart, this.scope);
 
-            await this.call(A_ServiceFeatures.onStart);
+            await this.call(A_ServiceFeatures.onStart, this.scope);
 
-            await this.call(A_ServiceFeatures.onAfterStart);
+            await this.call(A_ServiceFeatures.onAfterStart, this.scope);
 
         } catch (error) {
 
@@ -98,7 +98,7 @@ export class A_Service extends A_Container {
 
             this.scope.register(wrappedError);
 
-            await this.call(A_ServiceFeatures.onError);
+            await this.call(A_ServiceFeatures.onError, this.scope);
         }
 
     }
@@ -109,11 +109,11 @@ export class A_Service extends A_Container {
      */
     async stop() {
         try {
-            await this.call(A_ServiceFeatures.onBeforeStop);
+            await this.call(A_ServiceFeatures.onBeforeStop, this.scope);
 
-            await this.call(A_ServiceFeatures.onStop);
+            await this.call(A_ServiceFeatures.onStop, this.scope);
 
-            await this.call(A_ServiceFeatures.onAfterStop);
+            await this.call(A_ServiceFeatures.onAfterStop, this.scope);
 
         } catch (error) {
 
@@ -139,7 +139,7 @@ export class A_Service extends A_Container {
 
             this.scope.register(wrappedError);
 
-            await this.call(A_ServiceFeatures.onError);
+            await this.call(A_ServiceFeatures.onError, this.scope);
         }
     }
 

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

@@ -51,7 +51,7 @@ export type A_SignalVector_Serialized = A_TYPES__Entity_Serialized & {
 
 
 
-export type A_Signal_Init<T extends Record<string, any> = Record<string, any>> = {
+export type A_Signal_Init<T extends any = any> = {
     /**
      * Possible signal id
      * 
@@ -68,7 +68,7 @@ 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>> = {
+export type A_Signal_Serialized<T extends any = any> = {
     /**
      * The signal data
      */

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

@@ -1,6 +1,7 @@
-import { A_Entity, A_Scope } from "@adaas/a-concept";
+import { A_Entity } from "@adaas/a-concept";
 import { A_Signal_Init, A_Signal_Serialized } from "../A-Signal.types";
 import { A_Frame } from "@adaas/a-frame";
+import { A_UtilsHelper } from "@adaas/a-utils/helpers";
 
 /**
  * A Signal Entity is an individual signal instance that carries data.
@@ -21,23 +22,14 @@ import { A_Frame } from "@adaas/a-frame";
     description: 'A Signal Entity represents an individual signal instance that carries data, used for managing state within an application context. Signals are designed to reflect the current state rather than individual events, making them suitable for scenarios where state monitoring and real-time updates are essential.'
 })
 export class A_Signal<
-    _TSignalDataType extends Record<string, any> = Record<string, any>
-> extends A_Entity<A_Signal_Init<_TSignalDataType>, A_Signal_Serialized<_TSignalDataType>> {
+    _TSignalDataType extends any = any,
+    _TSignalSerializedDataType extends any = _TSignalDataType,
+> extends A_Entity<A_Signal_Init<_TSignalDataType>, A_Signal_Serialized<_TSignalSerializedDataType>> {
 
 
     // ========================================================================
     // ========================== Static Methods ==============================
     // ========================================================================
-    /**
-     * 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;
-    }
 
     // ========================================================================
     // ========================== Instance Properties ========================
@@ -48,69 +40,6 @@ export class A_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.
@@ -131,15 +60,37 @@ export class A_Signal<
 
         return true;
     }
-    
 
+    /**
+     * Allows to define default data for the signal.
+     * 
+     * If no data is provided during initialization, the default data will be used.
+     * 
+     * @returns 
+     */
+    fromUndefined(): void {
+        const name = (this.constructor as typeof A_Entity).entity;
+
+        this.data = undefined as unknown as _TSignalDataType;
 
-    fromJSON(serializedEntity: A_Signal_Serialized<_TSignalDataType>): void {
-        super.fromJSON(serializedEntity);
-        this.data = serializedEntity.data;
-    }
+        const identity = {
+            name: name,
+            data: this.data
+        };
 
+        const id = A_UtilsHelper.hash(identity);
 
+        this.aseid = this.generateASEID({
+            entity: name,
+            id: id,
+        });
+    }
+
+    /**
+     * Allows to initialize the signal from a new signal entity. This is useful for example when we want to create a new instance of the signal entity with the same data as another instance, but with a different ASEID.
+     * 
+     * @param newEntity 
+     */
     fromNew(newEntity: A_Signal_Init<_TSignalDataType>): void {
         this.data = newEntity.data;
 
@@ -148,7 +99,7 @@ export class A_Signal<
             data: this.data
         };
 
-        const id = this.createHash(identity);
+        const id = A_UtilsHelper.hash(identity);
 
         this.aseid = this.generateASEID({
             entity: newEntity.name,
@@ -156,11 +107,20 @@ export class A_Signal<
         });
     }
 
+    /**
+     * Allows to initialize the signal from a serialized version of the signal. This is useful for example when we receive a signal from the server and we want to create an instance of the signal entity from the received data.
+     * 
+     * @param serializedEntity 
+     */
+    fromJSON(serializedEntity: A_Signal_Serialized<_TSignalSerializedDataType>): void {
+        super.fromJSON(serializedEntity);
+        this.data = serializedEntity.data as unknown as _TSignalDataType;
+    }
 
-    toJSON(): A_Signal_Serialized<_TSignalDataType> {
+    toJSON(): A_Signal_Serialized<_TSignalSerializedDataType> {
         return {
             ...super.toJSON(),
-            data: this.data
+            data: this.data as unknown as _TSignalSerializedDataType
         };
     }
 

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

@@ -1,4 +1,4 @@
-import { A_Entity, A_Scope, A_TYPES__Component_Constructor, A_TYPES__Entity_Constructor } from "@adaas/a-concept";
+import { A_Entity, A_Scope, A_TypeGuards, A_TYPES__Component_Constructor, A_TYPES__Entity_Constructor } from "@adaas/a-concept";
 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";
@@ -107,10 +107,60 @@ export class A_SignalVector<
         };
     }
 
+    /**
+     * Checks that 2 vectors are identical by types and data 
+     * 
+     * e.g. [UserSignInSignal, UserStatusSignal] is equal to [UserSignInSignal, UserStatusSignal] with the same data, 
+     * but not equal to [UserStatusSignal, UserSignInSignal] or [UserSignInSignal, UserStatusSignal] with different data.
+     * 
+     * @param other 
+     * @returns 
+     */
+    equals(other: A_SignalVector<TSignals>): boolean {
+        if (this.structure.length !== other.structure.length) {
+            return false;
+        }
+
+        for (let i = 0; i < this.structure.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);
+
+            if (thisSignalIndex !== otherSignalIndex) {
+                return false;
+            }
+
+            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;
+    }
+
 
     /**
      * 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.
+     * This method returns true if all signals in the vector A match the corresponding signals in vector B, and false otherwise.
+     * 
+     * 
+     * e.g. [UserSignInSignal, UserStatusSignal] matches [UserStatusSignal, UserSignInSignal] with the same data,
+     * 
+     * but not matches [UserSignInSignal, UserStatusSignal] with different data or [UserSignInSignal] or [UserSignInSignal, UserStatusSignal, UserActivitySignal].
+     * 
      * 
      * @param other 
      * @returns 
@@ -146,13 +196,32 @@ export class A_SignalVector<
         return true;
     }
 
-    
+
+    /**
+     * Checks if the current Signal Vector includes all signals from another Signal Vector, regardless of order.
+     * 
+     * e.g. [UserSignInSignal, UserStatusSignal] includes [UserStatusSignal] with the same data,
+     * but not includes [UserStatusSignal] with different data or [UserActivitySignal].
+     * 
+     * @param other 
+     */
+    includes(other: A_SignalVector<TSignals>): boolean {
+        for (const signalConstructor of other.structure) {
+            const signalIndex = this._signals.findIndex(s => s.constructor === signalConstructor);
+            if (signalIndex === -1) {
+                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{
+    contains(signal: A_SignalVector): boolean {
         for (const signalConstructor of signal.structure) {
             const signalIndex = this._signals.findIndex(s => s.constructor === signalConstructor);
             if (signalIndex === -1) {
@@ -171,12 +240,12 @@ export class A_SignalVector<
     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) {
+        if (A_TypeGuards.isEntityInstance(param1)) {
             signalConstructor = param1.constructor as A_TYPES__Entity_Constructor<A_Signal>;
         } else {
             signalConstructor = param1;
         }
-        return this.structure.includes(signalConstructor as any);
+        return this.structure.includes(signalConstructor);
     }
 
     /**
@@ -210,11 +279,11 @@ export class A_SignalVector<
      * @param structure - Optional structure to override the default ordering
      * @returns Array of signal instances in the specified order
      */
-    async toVector<
+    toVector<
         T extends Array<A_Signal> = TSignals,
     >(
         structure?: A_Signal_TSignalsConstructors<T>
-    ): Promise<T> {
+    ): T {
         const usedStructure = structure || this.structure;
 
         return usedStructure.map((signalConstructor) => {
@@ -231,11 +300,11 @@ export class A_SignalVector<
      * @param structure - Optional structure to override the default ordering
      * @returns Array of serialized signal data in the specified order
      */
-    async toDataVector<
+    toDataVector<
         T extends A_Signal[] = TSignals,
     >(
         structure?: A_Signal_TSignalsConstructors<T>
-    ): Promise<A_SignalTValueArray<T>> {
+    ): A_SignalTValueArray<T> {
 
         const usedStructure = structure || this.structure;
 
@@ -246,7 +315,7 @@ export class A_SignalVector<
             let data: any;
             if (signalIndex === -1) {
 
-                data = await (signalConstructor as typeof A_Signal).default()
+                data = new (signalConstructor as typeof A_Signal)()
 
             } else {
                 const signal = this._signals[signalIndex];

package/tests/A-Signal.test.ts

@@ -29,8 +29,8 @@ describe('A-Signal tests', () => {
         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');
+        expect((vector.toDataVector())[0]?.buttonId).toBe('submit-order');
+        expect((vector.toDataVector())[1]?.pageId).toBe('home-page');
     });
     it('Should Allow to match Signal Vector', async () => {
         class MySignalA extends A_Signal<{ buttonId: string }> { }
@@ -57,7 +57,7 @@ describe('A-Signal tests', () => {
         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' } }),
@@ -142,7 +142,7 @@ describe('A-Signal tests', () => {
         expect(result).toBeDefined();
         expect(result).toBeInstanceOf(A_SignalVector);
         expect(result!.length).toBe(1);
-        expect((await result!.toDataVector())[0]?.buttonId).toBe('submit-order');
+        expect((result!.toDataVector())[0]?.buttonId).toBe('submit-order');
 
     });
     it('Should Allow to work with custom Signals', async () => {
@@ -150,10 +150,14 @@ describe('A-Signal tests', () => {
         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 }
-                }));
+            fromUndefined(): void {
+                super.fromNew({
+                    name: 'UserMousePositionSignal',
+                    data: {
+                        x: 0,
+                        y: 0
+                    }
+                })
             }
         }
         class UserElementHoverSignal extends A_Signal<{ elementId: string }> { }
@@ -208,10 +212,10 @@ describe('A-Signal tests', () => {
         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();
+        expect((result!.toDataVector())[0]?.buttonId).toBe('submit-order');
+        expect((result!.toDataVector())[1]?.x).toBe(0);
+        expect((result!.toDataVector())[1]?.y).toBe(0);
+        expect((result!.toDataVector())[2]).toBeUndefined();
 
     });