@adaas/a-concept 0.0.4 → 0.0.6

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,10 +77,112 @@ 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];
     }
-}
 
 
+    /**
+     * Method to delete values from the map
+     * 
+     * @param key 
+     * @returns 
+     */
+    delete(key: keyof _StorageItems): boolean {
+        return this.meta.delete(key);
+    }
+
+
+    /**
+     * 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()) {
+            if (regex.test(String(key))) {
+                results.push([key, value]);
+            }
+        }
+        return results;
+    }
+
+
+    /**
+     * Method to check if the map has a specific key
+     * 
+     * @param key 
+     * @returns 
+     */
+    has(key: keyof _StorageItems): boolean {
+        return this.meta.has(key);
+    }
+
+
+    /**
+     * Method to get the size of the map
+     * 
+     * @returns 
+     */
+    entries(): IterableIterator<[keyof _StorageItems, _StorageItems[keyof _StorageItems]]> {
+        return this.meta.entries();
+    }
+
+
+    /**
+     * Method to clear the map
+     */
+    clear(): void {
+        this.meta.clear();
+    }
+}

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

@@ -1,7 +1,10 @@
 import { A_CommonHelper } from "@adaas/a-utils";
 import { A_TYPES__ScopeConfig, A_TYPES__ScopeConstructor } from "./A-Scope.types";
-import { A_STORAGE__A_Inject_Instructions } from "@adaas/a-concept/storage/A_Inject.storage";
 import { A_Fragment } from "../A-Fragment/A-Fragment.class";
+import { A_Context } from "../A-Context/A-Context.class";
+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";
 
 /**
  * 
@@ -20,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;
 
@@ -125,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> {
@@ -150,44 +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 argsMeta = A_STORAGE__A_Inject_Instructions.get(component);
-
-                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);
@@ -200,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);
     }
 }

package/tsconfig.json

@@ -35,10 +35,6 @@
       "@adaas/a-concept/types/*": ["src/types/*"],
       "@adaas/a-concept/helpers/*": ["src/helpers/*"],
       "@adaas/a-concept/decorators/*": ["src/decorators/*"],
-      "@adaas/a-concept/managers/*": ["src/managers/*"],
-      "@adaas/a-concept/providers/*": ["src/providers/*"],
-      "@adaas/a-concept/modules/*": ["src/modules/*"],
-      "@adaas/a-concept/storage/*": ["src/storage/*"],
       "@adaas/a-concept/base/*": ["src/base/*"]
     },
     "lib": [

package/src/storage/A_Component.storage.ts

@@ -1,28 +0,0 @@
-// =================================================================================================
-// ========== Component Storage ====================================================================
-// =================================================================================================
-
-import { A_Component } from "../global/A-Component/A-Component.class";
-
-
-// -------------------------------------------------------------------------------
-// ----- A Concept -> Component Declaration -> Symbol Declaration Keys --------------- 
-// -------------------------------------------------------------------------------
-export const A_COMPONENT_STORAGE__Definition__Extensions = Symbol('a-container-extensions');
-export const A_COMPONENT_STORAGE__Definition__Feature = Symbol('a-container-feature');
-
-
-
-/**
- * 
- * This storage is used to store the containers metadata, definitions and configurations
- */
-export const A_COMPONENT_Storage: Map<
-    typeof A_Component | { new(...args: any[]): any },
-    Map<
-        Symbol | string,
-        any
-    >
-> = new Map();
-
-

package/src/storage/A_Concept.storage.ts

@@ -1,49 +0,0 @@
-
-
-// --------------------------------------------------------------
-// ----- A Concept -> Module Declaration -> Main Config ---------
-
-import { A_Container } from "../global/A-Container/A-Container.class";
-
-// --------------------------------------------------------------
-export const A_CONCEPT_STORAGE__MODULE_DECLARATION_Config = Symbol('a-concept-modules-declaration');
-
-
-
-// -------------------------------------------------------------------------------
-// ----- A Concept -> Module Declaration -> Concept Lifecycle Extension_ --------- 
-// -------------------------------------------------------------------------------
-export const A_CONCEPT_STORAGE__MODULE_DECLARATION_Lifecycle_RootRun = Symbol('a-concept-modules-declaration-lifecycle-root-run');
-export const A_CONCEPT_STORAGE__MODULE_DECLARATION_Lifecycle_RootLoad = Symbol('a-concept-modules-declaration-lifecycle-root-load');
-export const A_CONCEPT_STORAGE__MODULE_DECLARATION_Lifecycle_RootBuild = Symbol('a-concept-modules-declaration-lifecycle-root-build');
-export const A_CONCEPT_STORAGE__MODULE_DECLARATION_Lifecycle_RootPublish = Symbol('a-concept-modules-declaration-lifecycle-root-publish');
-export const A_CONCEPT_STORAGE__MODULE_DECLARATION_Lifecycle_RootTest = Symbol('a-concept-modules-declaration-lifecycle-root-test');
-
-
-
-
-/**
- * Storage to keep the module declarations across all modules
- */
-export const A_CONCEPT_ModulesDeclarationStorage: WeakMap<
-    any,
-    Map<string | Symbol, any>
-> = new WeakMap();
-
-
-
-/**
- * Storage to keep the lifecycle declarations across all modules
- */
-export const A_CONCEPT_LifecycleDeclarationsStorage: Map<Symbol, any> = new Map();
-
-
-
-
-
-/**
- * The simplest way to store the decorators
- * If any extra API is needed, it can be added here or replaced with a new class
- */
-export const A_CONCEPT_Storage = new WeakMap();
-

package/src/storage/A_Container.storage.ts

@@ -1,21 +0,0 @@
-// =================================================================================================
-// ========== Container Storage ====================================================================
-// =================================================================================================
-
-import { A_Container } from "../global/A-Container/A-Container.class";
-
-// -------------------------------------------------------------------------------
-// ----- A Concept -> Container Declaration -> Symbol Declaration Keys --------------- 
-// -------------------------------------------------------------------------------
-export const A_CONTAINER_STORAGE__Definition__Lifecycle = Symbol('a-container-lifecycle');
-export const A_CONTAINER_STORAGE__Definition__Feature = Symbol('a-container-feature');
-
-
-
-/**
- * This storage is used to store the containers metadata, definitions and configurations
- * 
- */
-export const A_CONTAINER_Storage: WeakMap<typeof A_Container.constructor, Map<Symbol | string, any>> = new WeakMap();
-
-

package/src/storage/A_Inject.storage.ts

@@ -1,30 +0,0 @@
-
-
-
-// =================================================================================================
-// ========== A-Inject Storage ====================================================================
-// =================================================================================================
-
-import { A_TYPES__A_InjectDecoratorStorageInstruction } from "../decorators/A-Inject/A-Inject.decorator.types";
-
-export const A_STORAGE__A_Inject_MethodArgumentsKey = Symbol('a-inject-method-arguments');
-
-
-/**
- * This storage is used to store the containers metadata, definitions and configurations
- * 
- */
-export const A_STORAGE__A_Inject_Instructions: WeakMap<
-    // Any Class
-    { new(...args: any[]): any },
-
-    // A set of instructions 
-    Map<
-        // Where key is method name
-        Symbol | string,
-        // And value is Injection instructions
-        A_TYPES__A_InjectDecoratorStorageInstruction
-    >
-> = new WeakMap();
-
-