@adaas/a-concept 0.0.5 → 0.0.6

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

@@ -1,7 +1,6 @@
 import { A_Feature_Define } from "@adaas/a-concept/decorators/A-Feature/A-Feature-Define.decorator";
 import { A_Feature_Extend } from "@adaas/a-concept/decorators/A-Feature/A-Feature-Extend.decorator";
-import { A_TYPES__FeatureConstructor, A_TYPES__FeatureState, A_TYPES__FeatureStep } from "./A-Feature.types";
-import { A_Scope } from "../A-Scope/A-Scope.class";
+import { A_TYPES__FeatureConstructor, A_TYPES__FeatureIteratorReturn, A_TYPES__FeatureState, A_TYPES__FeatureStep } from "./A-Feature.types";
 import { A_Error, A_TYPES__Required } from "@adaas/a-utils";
 import { A_Context } from "../A-Context/A-Context.class";
 
@@ -37,7 +36,9 @@ export class A_Feature {
 
 
     // protected scope: A_Scope
-    protected steps: A_TYPES__FeatureStep[] = []
+    protected steps: A_TYPES__FeatureStep[] = [];
+    protected _current?: A_TYPES__FeatureStep;
+    protected _index: number = 0;
 
     state: A_TYPES__FeatureState = A_TYPES__FeatureState.INITIALIZED;
 
@@ -55,6 +56,61 @@ export class A_Feature {
     }
 
 
+    /**
+     * Custom iterator to iterate over the steps of the feature
+     * 
+     * @returns 
+     */
+    [Symbol.iterator](): Iterator<A_TYPES__FeatureIteratorReturn, any> {
+        return {
+            // Custom next method
+            next: (): IteratorResult<A_TYPES__FeatureIteratorReturn, any> => {
+                if (this._index < this.steps.length) {
+                    if (
+                        (this.state as any) === A_TYPES__FeatureState.FAILED
+                        ||
+                        (this.state as any) === A_TYPES__FeatureState.COMPLETED
+                    ) {
+                        throw new Error('FEATURE_PROCESSING_INTERRUPTED');
+                    }
+
+                    this._current = this.steps[this._index];
+
+                    const { component, handler, args } = this._current;
+
+                    const instance = A_Context.scope(this).resolve(component);
+
+                    return {
+                        value: async () => {
+
+                            if (instance[handler]) {
+                                const callArgs = A_Context.scope(this).resolve(args);
+                                await instance[handler](...callArgs);
+                            }
+
+                            this._index++;
+                        },
+                        done: false
+                    };
+                } else {
+                    this._current = undefined; // Reset current on end
+                    return { value: undefined, done: true };
+                }
+            }
+        };
+    }
+
+    // Access the current element
+    get current(): A_TYPES__FeatureStep | undefined {
+        return this._current;
+    }
+
+    // Custom end strategy or stop condition (could be expanded if needed)
+    isDone(): boolean {
+        return this.current === null;
+    }
+
+
     /**
      * This method marks the feature as completed and returns the result
      * Uses to interrupt or end the feature processing
@@ -94,28 +150,14 @@ export class A_Feature {
         try {
             this.state = A_TYPES__FeatureState.PROCESSING;
 
-            for (const { component, handler, args } of this.steps) {
-
-                if (
-                    (this.state as any) === A_TYPES__FeatureState.FAILED
-                    ||
-                    (this.state as any) === A_TYPES__FeatureState.COMPLETED
-                ) {
-                    throw new Error('FEATURE_PROCESSING_INTERRUPTED');
-                }
-
-                const instance = A_Context.scope(this).resolve(component);
-
-                if (instance[handler]) {
-                    const callArgs = A_Context.scope(this).resolve(args);
-                    await instance[handler](...callArgs);
-                }
+            for (const step of this) {
+                await step();
             }
 
             await this.completed();
 
         } catch (error) {
-            console.log('Feature processing error:', error);
+            console.log('[!] Feature processing error:', error);
 
             await this.failed(error);
         }

package/src/global/A-Feature/A-Feature.types.ts

@@ -1,5 +1,11 @@
+import { A_Component } from "../A-Component/A-Component.class"
+import { A_TYPES__ComponentMeta_InjectionParam } from "../A-Component/A-Component.types"
 import { A_TYPES__ScopeConfig, A_TYPES__ScopeConstructor } from "../A-Scope/A-Scope.types"
 
+
+export type A_TYPES__FeatureIteratorReturn<T extends any = any> = () => Promise<T>
+
+
 export type A_TYPES__FeatureConstructor = {
     steps: A_TYPES__FeatureStep[]
 } & A_TYPES__ScopeConstructor & A_TYPES__ScopeConfig
@@ -14,7 +20,7 @@ export enum A_TYPES__FeatureState {
 
 
 export type A_TYPES__FeatureStep = {
-    component: { new(...args: any[]): any },
+    component: typeof A_Component,
     handler: string,
-    args: any[]
+    args: A_TYPES__ComponentMeta_InjectionParam[]
 }

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

@@ -28,11 +28,7 @@ export class A_Fragment {
         /**
          * Register the Namespace in the global Namespace provider
          */
-        this.name = A_Context
-            .register(
-                this,
-                this.name
-            );
+        this.name = params.name || this.constructor.name;
 
         /**
          * Run Async Initialization

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

@@ -1,7 +1,9 @@
-import { A_TYPES__Dictionary } from "@adaas/a-utils";
-import { A_Component } from "../A-Component/A-Component.class";
-import { A_Container } from "../A-Container/A-Container.class";
-
+// 
+// 
+// 
+// 
+// 
+// 
 
 
 /**
@@ -12,11 +14,34 @@ import { A_Container } from "../A-Container/A-Container.class";
 export class A_Meta<
     _StorageItems extends Record<string, any>
 // _StorageItems extends Record<string, Map<string | Symbol, any> | Array<any> | A_TYPES__Dictionary<any>>
-> {
+> implements Iterable<[keyof _StorageItems, _StorageItems[keyof _StorageItems]]> {
 
     protected meta: Map<keyof _StorageItems, _StorageItems[keyof _StorageItems]> = new Map();
 
 
+    /**
+     * Method to get the iterator for the meta object
+     * 
+     * @returns 
+     */
+    [Symbol.iterator](): Iterator<[keyof _StorageItems, _StorageItems[keyof _StorageItems]]> {
+        const iterator = this.meta.entries();
+        return {
+            next: () => iterator.next()
+        };
+    }
+
+
+
+    // ===================================================================================================
+    // ================================ META OPERATIONS ==================================================
+    // ===================================================================================================
+    /**
+     * Allows to replicate received meta object by replacing internal meta to the received one
+     * 
+     * @param meta 
+     * @returns 
+     */
     from(
         meta: A_Meta<_StorageItems>
     ): A_Meta<_StorageItems> {
@@ -26,11 +51,12 @@ export class A_Meta<
     }
 
 
-    // ===================================================================================================
-    // ================================ META OPERATIONS ==================================================
-    // ===================================================================================================
-
-    // Method to set values in the map
+    /**
+     * Method to set values in the map
+     * 
+     * @param key 
+     * @param value 
+     */
     set<K extends keyof _StorageItems>(key: K, value: _StorageItems[K]) {
 
         const inheritedValue = this.meta.get(key)
@@ -51,18 +77,76 @@ export class A_Meta<
 
     }
 
-    // Method to get values from the map
+
+
+    /**
+     * Method to get values from the map
+     * 
+     * @param key 
+     * @returns 
+     */
     get<K extends keyof _StorageItems>(key: K): _StorageItems[K] | undefined {
         return this.meta.get(key) as _StorageItems[K];
     }
 
 
-    // Delete a key-value pair by key
+    /**
+     * Method to delete values from the map
+     * 
+     * @param key 
+     * @returns 
+     */
     delete(key: keyof _StorageItems): boolean {
         return this.meta.delete(key);
     }
 
-    // Search for keys by regex
+
+    /**
+     * This method is needed to convert the key to a regular expression and cover cases like: 
+     * 
+     * simple * e.g. "a*" instead of "a.*"
+     * 
+     * simple ? e.g. "a?" instead of "a."
+     * 
+     * etc. 
+     * 
+     * @param key 
+     * @returns 
+     */
+    private convertToRegExp(key: string | RegExp): RegExp {
+        return key instanceof RegExp
+            ? key
+            : new RegExp(key);
+    }
+
+
+    /**
+     * Method to find values in the map by name.
+     * 
+     * Converts the Key in Map to a regular expression and then compares to the name
+     * 
+     * @param name 
+     * @returns 
+     */
+    find(name: string) {
+        const results: Array<[keyof _StorageItems, _StorageItems[keyof _StorageItems]]> = [];
+        for (const [key, value] of this.meta.entries()) {
+            if (this.convertToRegExp(name).test(key as string)) {
+                results.push([key, value]);
+            }
+        }
+        return results;
+    }
+
+
+    /**
+     * Method to find values in the map by regular expression
+     * 
+     * Compares Map Key to the input regular expression
+     * 
+     * @param regex 
+     * @returns 
+     */
     findByRegex(regex: RegExp): Array<[keyof _StorageItems, _StorageItems[keyof _StorageItems]]> {
         const results: Array<[keyof _StorageItems, _StorageItems[keyof _StorageItems]]> = [];
         for (const [key, value] of this.meta.entries()) {
@@ -73,24 +157,32 @@ export class A_Meta<
         return results;
     }
 
-    // Check if a key exists
+
+    /**
+     * Method to check if the map has a specific key
+     * 
+     * @param key 
+     * @returns 
+     */
     has(key: keyof _StorageItems): boolean {
         return this.meta.has(key);
     }
 
-    // Get all entries in the map
+
+    /**
+     * Method to get the size of the map
+     * 
+     * @returns 
+     */
     entries(): IterableIterator<[keyof _StorageItems, _StorageItems[keyof _StorageItems]]> {
         return this.meta.entries();
     }
 
 
-    // Clear all entries
+    /**
+     * Method to clear the map
+     */
     clear(): void {
         this.meta.clear();
     }
-
-
-
-}
-
-
+}

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

@@ -2,7 +2,9 @@ import { A_CommonHelper } from "@adaas/a-utils";
 import { A_TYPES__ScopeConfig, A_TYPES__ScopeConstructor } from "./A-Scope.types";
 import { A_Fragment } from "../A-Fragment/A-Fragment.class";
 import { A_Context } from "../A-Context/A-Context.class";
-import { A_TYPES__ComponentMetaKey } from "../A-Component/A-Component.types";
+import { A_TYPES__ComponentMeta_InjectionParam, A_TYPES__ComponentMetaKey } from "../A-Component/A-Component.types";
+import { A_Component } from "../A-Component/A-Component.class";
+import { A_Entity } from "../A-Entity/A-Entity.class";
 
 /**
  * 
@@ -21,8 +23,9 @@ export class A_Scope {
 
     name: string = '';
 
-    private _components: WeakMap<{ new(...args: any[]): any }, any> = new WeakMap();
+    private _components: WeakMap<typeof A_Component.constructor, any> = new WeakMap();
     private _fragments: WeakMap<typeof A_Fragment.constructor, any> = new WeakMap();
+    private _entities: Map<string, A_Entity> = new Map();
 
     private parent?: A_Scope;
 
@@ -126,10 +129,10 @@ export class A_Scope {
      * @param component 
      * @returns 
      */
-    resolve<T extends { new(...args: any[]): any }>(component: T): InstanceType<T>
-    resolve<T extends { new(...args: any[]): any }>(component: Array<T>): Array<InstanceType<T>>
+    resolve<T extends A_TYPES__ComponentMeta_InjectionParam>(component: T): InstanceType<T>
+    resolve<T extends A_TYPES__ComponentMeta_InjectionParam>(component: Array<T>): Array<InstanceType<T>>
     // base definition
-    resolve<T extends { new(...args: any[]): any }>(
+    resolve<T extends A_TYPES__ComponentMeta_InjectionParam>(
         param1: Array<T> | T,
         param2?: string
     ): Array<InstanceType<T>> | InstanceType<T> {
@@ -151,46 +154,28 @@ export class A_Scope {
 
 
 
-
-    private resolveOnce<T extends { new(...args: any[]): any }>(component: T): InstanceType<T> {
+    private resolveOnce<T extends A_TYPES__ComponentMeta_InjectionParam>(component: T): InstanceType<T> {
         switch (true) {
             case A_CommonHelper.isInheritedFrom(component, A_Fragment): {
-                return this.resolveFragment(component);
+                return this.resolveFragment(component as typeof A_Fragment) as InstanceType<T>;
             }
 
-            case this.components.includes(component) && this._components.has(component): {
-
-                return this._components.get(component);
+            case A_CommonHelper.isInheritedFrom(component, A_Scope): {
+                return this.resolveScope(component as typeof A_Scope) as InstanceType<T>;
             }
-            case this.components.includes(component) && !this._components.has(component): {
-
-                const componentMeta = A_Context.meta(component)
-
-                const argsMeta = componentMeta.get(A_TYPES__ComponentMetaKey.INJECTIONS);
-
-                let resolvedArgs: Array<any> = [];
-
-                if (argsMeta)
-                    resolvedArgs = (argsMeta.get('constructor') || [])
-                        .map(arg => this.resolve(arg));
 
-                this._components.set(component, new component());
-
-                return this._components.get(component);
+            case A_CommonHelper.isInheritedFrom(component, A_Component): {
+                return this.resolveComponent(component as typeof A_Component) as InstanceType<T>;
             }
 
-            case !this.components.includes(component) && !!this.parent: {
-
-                return this.parent.resolve(component);
-            }
             default:
-                throw new Error(`Component ${component.name} not found in the scope`);
+                throw new Error(`Injected Component ${component} not found in the scope`);
         }
     }
 
 
 
-    private resolveFragment<T extends { new(...args: any[]): any }>(fragment: T): InstanceType<T> {
+    private resolveFragment<T extends typeof A_Fragment>(fragment: T): InstanceType<T> {
 
         if (this._fragments.has(fragment)) {
             return this._fragments.get(fragment);
@@ -203,9 +188,91 @@ export class A_Scope {
         throw new Error(`Fragment ${fragment.name} not found in the scope ${this.name}`);
     }
 
+    private resolveScope<T extends { new(...args: any[]): A_Scope }>(scope: T): InstanceType<T> {
+
+        if (A_CommonHelper.isInheritedFrom(scope, this.constructor)) {
+            return this as InstanceType<T>;
+        } else if (this.parent) {
+            return this.parent.resolveScope(scope);
+        }
+
+        throw new Error(`Scope ${scope.name} not found in the scope ${this.name}`);
+    }
+
+
+    private resolveComponent<T extends A_Component>(component: {
+        new(...args: any[]): T
+    }): T {
+
+        if (this.components.includes(component) && this._components.has(component))
+            return this._components.get(component);
+
+        else if (this.components.includes(component) && !this._components.has(component)) {
+            const componentMeta = A_Context.meta(component)
+
+            const argsMeta = componentMeta.get(A_TYPES__ComponentMetaKey.INJECTIONS);
+
+            const resolvedArgs = (argsMeta?.get('constructor') || [])
+                .map(arg => this.resolve(arg));
+
+            const newComponent = new component(...resolvedArgs)
+
+            this.register(newComponent);
+
+            return this._components.get(component);
+        }
+
+        else if (!this.components.includes(component) && !!this.parent) {
+            return this.parent.resolveComponent(component);
+        }
+
+        else {
+            throw new Error(`Component ${component.name} not found in the scope`);
+        }
+    }
+
+
+
+    /**
+     * This method is used to register the component in the scope
+     * 
+     * @param fragment 
+     */
+    register(fragment: A_Entity): void
+    register(fragment: A_Component): void
+    register(fragment: A_Fragment): void
+    register(
+        param1: A_Fragment | A_Component | A_Entity
+    ): void {
+
+
+        switch (true) {
+            case param1 instanceof A_Fragment && !this._fragments.has(param1.constructor): {
+                this._fragments.set(param1.constructor, param1);
+                // The same situation. Have not idea how to fix it
+                A_Context.register(this, param1 as any);
+                break;
+            }
+
+            case param1 instanceof A_Entity && !this._entities.has(param1.aseid.toString()): {
+                this._entities.set(param1.aseid.toString(), param1);
+                // The same situation. Have not idea how to fix it
+                A_Context.register(this, param1 as any);
+                break;
+            }
+
+            case param1 instanceof A_Component: {
+                this._components.set(param1.constructor, param1);
+                // The same situation. Have not idea how to fix it
+                A_Context.register(this, param1 as any);
+                break;
+            }
+
+            default:
+                throw new Error('Invalid arguments provided');
+        }
+
 
 
-    register(fragment: A_Fragment): void {
-        this._fragments.set(fragment.constructor, fragment);
     }
 }