@adaas/a-concept 0.0.32 → 0.0.34

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

@@ -1,4 +1,8 @@
-import { A_CommonHelper, A_Polyfills, A_TYPES__Required, ASEID } from "@adaas/a-utils";
+import {
+    A_CommonHelper,
+    A_Polyfills,
+    A_TYPES__Required,
+} from "@adaas/a-utils";
 import { A_Component } from "../A-Component/A-Component.class";
 import { A_Fragment } from "../A-Fragment/A-Fragment.class";
 import { A_Feature } from "../A-Feature/A-Feature.class";
@@ -8,15 +12,15 @@ import { A_TYPES__ScopeConfig, A_TYPES__ScopeConstructor } from "../A-Scope/A-Sc
 import { A_Meta } from "../A-Meta/A-Meta.class";
 import { A_ComponentMeta } from "../A-Component/A-Component.meta";
 import { A_ContainerMeta } from "../A-Container/A-Container.meta";
-import { A_Concept } from "../A-Concept/A_Concept.class";
 import { A_TYPES__EntityBaseMethod, A_TYPES__EntityMetaKey } from "../A-Entity/A-Entity.types";
 import { A_Entity } from "../A-Entity/A-Entity.class";
 import { A_EntityMeta } from "../A-Entity/A-Entity.meta";
 import { A_TYPES__FeatureConstructor } from "../A-Feature/A-Feature.types";
 import { A_TYPES__A_StageStep } from "../A-Stage/A-Stage.types";
-import { A_TYPES__A_DefineDecorator_Meta, A_TYPES__A_FeatureDecoratorConfig } from "@adaas/a-concept/decorators/A-Feature/A-Feature.decorator.types";
 import { A_TYPES__ContainerMetaKey } from "../A-Container/A-Container.types";
 import { A_TYPES__ComponentMetaKey } from "../A-Component/A-Component.types";
+import { A_TYPES__ConceptStage } from "../A-Concept/A_Concept.types";
+
 
 
 /**
@@ -33,25 +37,19 @@ export class A_Context {
     /**
      * A set of globally registered containers.
      */
-    protected containers: WeakMap<A_Container<any>, A_Scope> = new WeakMap();
+    protected containers: WeakMap<A_Container, A_Scope> = new WeakMap();
 
     /**
      * A set of globally registered features.
      */
     protected features: WeakMap<A_Feature, A_Scope> = new WeakMap();
 
-    /**
-     * A set of globally registered concepts.
-     */
-    protected concepts: WeakMap<A_Concept<any>, A_Scope> = new WeakMap();
-
 
     /**
      * Uses to store the scope of every element in the program. 
      */
     protected registry: WeakMap<
-        A_Concept<any> |
-        A_Container<any> |
+        A_Container |
         A_Feature |
         A_Component |
         A_Fragment |
@@ -65,7 +63,6 @@ export class A_Context {
     /**
      * A set of allocated scopes per every element in the program.
      */
-    protected conceptsMeta: Map<typeof A_Concept.constructor, A_Meta<any>> = new Map();
     protected containersMeta: Map<typeof A_Container.constructor, A_ContainerMeta> = new Map();
     protected componentsMeta: Map<typeof A_Component, A_ComponentMeta> = new Map();
     protected entitiesMeta: Map<typeof A_Entity.constructor, A_EntityMeta> = new Map();
@@ -77,10 +74,14 @@ export class A_Context {
     /**
      * Root Namespace is a Namespace that is used to run the program.
      */
-    private _root!: string
+    private _root!: A_Scope
 
 
-    private constructor() { }
+    private constructor() {
+        this._root = new A_Scope({
+            name: 'root'
+        });
+    }
 
 
 
@@ -103,7 +104,7 @@ export class A_Context {
         return A_Context.instance;
     }
 
-    static get root(): string {
+    static get root(): A_Scope {
         return this.getInstance()._root;
     }
 
@@ -113,7 +114,6 @@ export class A_Context {
 
 
 
-
     static allocate(
         component: any,
         importing: Partial<A_TYPES__ScopeConstructor & A_TYPES__ScopeConfig>
@@ -123,11 +123,11 @@ export class A_Context {
         importing: Partial<A_TYPES__ScopeConstructor & A_TYPES__ScopeConfig>
     ): A_Scope
     static allocate(
-        container: A_Container<any>,
+        container: A_Container,
         importing: Partial<A_TYPES__ScopeConstructor & A_TYPES__ScopeConfig>
     ): A_Scope
     static allocate(
-        param1: A_Container<any> | A_Feature | A_Component | any,
+        param1: A_Container | A_Feature | A_Component | any,
         param2: Partial<A_TYPES__ScopeConstructor & A_TYPES__ScopeConfig>
     ): A_Scope {
 
@@ -138,17 +138,14 @@ export class A_Context {
         switch (true) {
             case param1 instanceof A_Container:
                 instance.containers.set(param1, newScope);
+
                 break;
 
             case param1 instanceof A_Feature:
                 instance.features.set(param1, newScope);
-                break;
 
-            case param1 instanceof A_Concept:
-                instance.concepts.set(param1, newScope);
                 break;
 
-
             default:
                 throw new Error(`[!] A-Concept Context: Unknown type of the parameter.`);
         }
@@ -164,7 +161,7 @@ export class A_Context {
         container: typeof A_Container,
     ): A_ContainerMeta
     static meta(
-        container: A_Container<any>,
+        container: A_Container,
     ): A_ContainerMeta
     static meta(
         entity: A_Entity,
@@ -179,17 +176,14 @@ export class A_Context {
         component: A_Component,
     ): A_ComponentMeta
     static meta<T extends Record<string, any>>(
-        component: { new(...args: any[]): any },
-    ): A_Meta<T>
-    static meta<T extends Record<string, any>>(
-        param1: A_Container<any>
-            | typeof A_Container
+        param1: typeof A_Component | typeof A_Container | A_Container
             | A_Component
-            | typeof A_Component
             | A_Entity
             | typeof A_Entity
             | { new(...args: any[]): any }
     ): A_ContainerMeta | A_ComponentMeta | A_Meta<T> {
+
+
         const instance = this.getInstance();
 
         let metaStorage: WeakMap<typeof A_Container.constructor, A_Meta<any>>;
@@ -209,7 +203,7 @@ export class A_Context {
 
             case A_CommonHelper.isInheritedFrom(param1, A_Container): {
                 metaStorage = instance.containersMeta;
-                property = param1 as typeof A_Container<any>;
+                property = param1 as typeof A_Container;
                 metaType = A_ContainerMeta;
 
                 break;
@@ -256,11 +250,13 @@ export class A_Context {
             }
         }
 
+
         if (!metaStorage.has(property)) {
             const inheritMeta = metaStorage.get(Object.getPrototypeOf(property)) || new metaType();
             metaStorage.set(property, new metaType().from(inheritMeta as any));
         }
 
+
         return metaStorage.get(property)!;
     }
 
@@ -273,10 +269,7 @@ export class A_Context {
         component: A_Component
     ): A_Scope
     static scope(
-        concept: A_Concept
-    ): A_Scope
-    static scope(
-        container: A_Container<any>
+        container: A_Container
     ): A_Scope
     static scope(
         feature: A_Fragment
@@ -285,7 +278,7 @@ export class A_Context {
         feature: A_Feature
     ): A_Scope
     static scope(
-        param1: A_Feature | A_Container<any> | A_Concept | A_Component<any> | A_Entity | A_Fragment
+        param1: A_Feature | A_Container | A_Component | A_Entity | A_Fragment
     ): A_Scope | undefined {
 
         const instance = this.getInstance();
@@ -297,9 +290,6 @@ export class A_Context {
             case param1 instanceof A_Feature:
                 return instance.features.get(param1);
 
-            case param1 instanceof A_Concept:
-                return instance.concepts.get(param1);
-
             case param1 instanceof A_Entity:
                 return instance.registry.get(param1);
 
@@ -347,16 +337,16 @@ export class A_Context {
      * @param scope 
      * @returns 
      */
-    static featureDefinition<T extends Array<string>>(
+    static featureDefinition(
         scope: A_Scope,
-        entity: A_Entity<any, any, T>,
-        feature: A_TYPES__EntityBaseMethod | string | T[number] | RegExp,
+        entity: A_Entity,
+        feature: A_TYPES__EntityBaseMethod | string | RegExp,
         params?: Partial<A_TYPES__ScopeConstructor>
     ): A_TYPES__Required<Partial<A_TYPES__FeatureConstructor>, ['steps', 'fragments', 'name', 'components']>
-    static featureDefinition<T extends Array<string>>(
+    static featureDefinition(
         scope: A_Scope,
-        container: A_Container<T>,
-        feature: T[number],
+        container: A_Container,
+        feature: string,
         params?: Partial<A_TYPES__ScopeConstructor>
     ): A_TYPES__Required<Partial<A_TYPES__FeatureConstructor>, ['steps', 'fragments', 'name', 'components']>
     static featureDefinition(
@@ -365,10 +355,10 @@ export class A_Context {
         feature: string,
         params?: Partial<A_TYPES__ScopeConstructor>
     ): A_TYPES__Required<Partial<A_TYPES__FeatureConstructor>, ['steps', 'fragments', 'name', 'components']>
-    static featureDefinition<T extends Array<string>>(
+    static featureDefinition(
         scope: A_Scope,
-        param1: A_Component<T> | A_Container<T> | A_Entity<any, any, T>,
-        param2: string | T[number],
+        param1: A_Component | A_Container | A_Entity,
+        param2: string,
         param3?: Partial<A_TYPES__ScopeConstructor>
     ): A_TYPES__Required<Partial<A_TYPES__FeatureConstructor>, ['steps', 'fragments', 'name', 'components']> {
         const instance = this.getInstance();
@@ -416,14 +406,18 @@ export class A_Context {
             case component instanceof A_Container:
                 metaKey = A_TYPES__ContainerMetaKey.FEATURES
                 break;
-            case component instanceof A_Component:
+            case component instanceof A_Component: {
                 metaKey = A_TYPES__ComponentMetaKey.FEATURES
+            }
                 break;
             default:
                 throw new Error(`A-Feature cannot be defined on the ${component} level`);
         }
 
-        const featureDefinition: A_TYPES__A_DefineDecorator_Meta = this.meta(component).get(metaKey);
+
+        const featureDefinition = this.meta(component)
+            .get(metaKey)
+            .get(param2);
 
         if (!featureDefinition)
             throw new Error(`[!] A-Concept Context: Feature not found.`);
@@ -464,12 +458,101 @@ export class A_Context {
             name: feature,
             fragments: config.fragments || [],
             components: config.components || [],
+            entities: config.entities || [],
             steps,
             parent: scope
         };
     }
 
+    /**
+     * This method returns a constructor params to create a new feature
+     * 
+     * @param scope 
+     * @returns 
+     */
+    static abstractionDefinition(
+        scope: A_Scope,
+        entity: A_Entity,
+        feature: A_TYPES__ConceptStage,
+        params?: Partial<A_TYPES__ScopeConstructor>
+    ): A_TYPES__Required<Partial<A_TYPES__FeatureConstructor>, ['steps', 'fragments', 'name', 'components']>
+    static abstractionDefinition(
+        scope: A_Scope,
+        container: A_Container,
+        feature: A_TYPES__ConceptStage,
+        params?: Partial<A_TYPES__ScopeConstructor>
+    ): A_TYPES__Required<Partial<A_TYPES__FeatureConstructor>, ['steps', 'fragments', 'name', 'components']>
+    static abstractionDefinition(
+        scope: A_Scope,
+        component: A_Component,
+        feature: A_TYPES__ConceptStage,
+        params?: Partial<A_TYPES__ScopeConstructor>
+    ): A_TYPES__Required<Partial<A_TYPES__FeatureConstructor>, ['steps', 'fragments', 'name', 'components']>
+    static abstractionDefinition(
+        scope: A_Scope,
+        param1: A_Component | A_Container | A_Entity,
+        param2: A_TYPES__ConceptStage,
+        param3?: Partial<A_TYPES__ScopeConstructor>
+    ): A_TYPES__Required<Partial<A_TYPES__FeatureConstructor>, ['steps', 'fragments', 'name', 'components']> {
+        const instance = this.getInstance();
+
+        const component = param1;
+        const config = param3 || {};
+     
+        let metaKey;
+
+        switch (true) {
+            case component instanceof A_Entity:
+                metaKey = A_TYPES__EntityMetaKey.FEATURES;
+                break;
+            case component instanceof A_Container:
+                metaKey = A_TYPES__ContainerMetaKey.ABSTRACTIONS
+                break;
+            case component instanceof A_Component: {
+                metaKey = A_TYPES__ComponentMetaKey.ABSTRACTIONS
+            }
+                break;
+            default:
+                throw new Error(`A-Feature cannot be defined on the ${component} level`);
+        }
+
+        const featureDefinition = this.meta(component)
+            .get(metaKey)
+            .get(param2) || []
+
+
+        const steps: A_TYPES__A_StageStep[] = [
+            ...featureDefinition
+        ];
+
+        const feature = `${component.constructor.name}.${param2}`;
+
+        // We need to get all components that has extensions for the feature in component
+        instance.componentsMeta
+            .forEach((meta, constructor) => {
+                // Just try to make sure that component not only Indexed but also presented in scope
+                if (scope.has(constructor))
+                    // Get all extensions for the feature
+                    meta
+                        .abstractions(feature)
+                        .forEach((declaration) => {
+                            steps.push({
+                                component: constructor,
+                                ...declaration
+                            });
+                        });
+            });
+
 
+        return {
+            name: feature,
+            fragments: config.fragments || [],
+            components: config.components || [],
+            entities: config.entities || [],
+            steps,
+            parent: scope
+        };
+    }
 
     /**
      * This method returns a step-by-step instructions of feature implementation depending on the feature name and the class.
@@ -479,13 +562,13 @@ export class A_Context {
      */
     static feature<T extends Array<string>>(
         scope: A_Scope,
-        entity: A_Entity<any, any, T>,
+        entity: A_Entity<any, any>,
         feature: A_TYPES__EntityBaseMethod | string | T[number] | RegExp,
         params?: Partial<A_TYPES__ScopeConstructor>
     ): A_Feature
     static feature<T extends Array<string>>(
         scope: A_Scope,
-        container: A_Container<T>,
+        container: A_Container,
         feature: T[number],
         params?: Partial<A_TYPES__ScopeConstructor>
     ): A_Feature
@@ -497,7 +580,7 @@ export class A_Context {
     ): A_Feature
     static feature<T extends Array<string>>(
         scope: A_Scope,
-        param1: A_Component<T> | A_Container<T> | A_Entity<any, any, T>,
+        param1: A_Component | A_Container | A_Entity<any, any>,
         param2: string | T[number],
         param3?: Partial<A_TYPES__ScopeConstructor>
     ): A_Feature {
@@ -517,7 +600,7 @@ export class A_Context {
      */
     static register(
         scope: A_Scope,
-        container: A_Container<any>
+        container: A_Container
     )
     static register(
         scope: A_Scope,
@@ -533,12 +616,12 @@ export class A_Context {
     )
     static register(
         scope: A_Scope,
-        param1: A_Fragment | A_Container<any> | A_Entity | A_Component
+        param1: A_Fragment | A_Container | A_Entity | A_Component
     ) {
         const instance = this.getInstance();
 
-        if (!instance._root)
-            instance._root = scope.name;
+        // if (!instance._root)
+        //     instance._root = scope.name;
 
         switch (true) {
             case param1 instanceof A_Component:

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

@@ -1,18 +1,15 @@
 import {
     A_CommonHelper,
-    A_Error, A_TYPES__Required,
+    A_Error,
     ASEID
 } from "@adaas/a-utils";
 import {
     A_TYPES__Entity_JSON,
-    A_TYPES__EntityBaseMethod,
-    A_TYPES__EntityBaseMethods,
-    A_TYPES__EntityCallParams,
     A_TYPES__IEntity
 } from "./A-Entity.types";
 import { A_CONSTANTS__DEFAULT_ERRORS } from "@adaas/a-utils/dist/src/constants/errors.constants";
 import { A_Context } from "../A-Context/A-Context.class";
-import { A_Fragment } from "../A-Fragment/A-Fragment.class";
+import { A_TYPES__FeatureCallParams } from "../A-Feature/A-Feature.types";
 
 
 
@@ -25,8 +22,7 @@ import { A_Fragment } from "../A-Fragment/A-Fragment.class";
  */
 export class A_Entity<
     _ConstructorType = any,
-    _SerializedType extends A_TYPES__Entity_JSON = A_TYPES__Entity_JSON,
-    _FeatureNames extends Array<string | A_TYPES__EntityBaseMethod> = A_TYPES__EntityBaseMethods
+    _SerializedType extends A_TYPES__Entity_JSON = A_TYPES__Entity_JSON
 >
     implements A_TYPES__IEntity {
 
@@ -57,7 +53,7 @@ export class A_Entity<
     )
     constructor(props: string | ASEID | _SerializedType | _ConstructorType) {
 
-        
+
         switch (true) {
             case (typeof props === 'string' && ASEID.isASEID(props)):
                 this.aseid = new ASEID(props);
@@ -139,43 +135,12 @@ export class A_Entity<
      * @param lifecycleMethod 
      * @param args 
      */
-    async call(
-        /**
-         * A-Feature method name to be called
-         */
-        feature: _FeatureNames[number],
-    ): Promise<any>
-    async call(
-        /**
-         * A-Feature name to be called
-         */
-        params: A_TYPES__Required<Partial<A_TYPES__EntityCallParams<_FeatureNames[number]>>, ['name']>,
-    ): Promise<any>
-    async call(
-        /**
-        * A-Feature method name to be called
-        */
-        feature: _FeatureNames[number],
-        /**
-         * Parameters to provide additional data to the feature
-         */
-        params: Partial<A_TYPES__EntityCallParams<_FeatureNames[number]>>,
-    ): Promise<any>
-
-    async call(
-        param1: _FeatureNames[number] | A_TYPES__Required<Partial<A_TYPES__EntityCallParams<_FeatureNames[number]>>, ['name']>,
-        param2?: Partial<A_TYPES__EntityCallParams<_FeatureNames[number]>>
-    ): Promise<any> {
-
-        const feature: string = typeof param1 === 'string'
-            ? param1
-            : param1.name;
-        const params: Partial<A_TYPES__EntityCallParams<_FeatureNames[number]>> = typeof param1 === 'string'
-            ? param2 || {}
-            : param1;
-
-
-        console.log('WTF???? ', A_Context.scope(this))
+     async call(
+        feature: string,
+        params: Partial<A_TYPES__FeatureCallParams> = {}
+    ) {
+        params.entities = params.entities || [this];
+
 
         const newFeature = A_Context.feature(A_Context.scope(this), this, feature, params);
 
@@ -188,33 +153,21 @@ export class A_Entity<
     // ====================================================================
 
 
-    async load() {
-        await this.call(A_TYPES__EntityBaseMethod.DESTROY, {
-            entities: [
-                this
-            ]
-        });
-    }
-
-
-
-    async destroy() {
-        await this.call(A_TYPES__EntityBaseMethod.DESTROY, {
-            entities: [
-                this
-            ],
-        });
-    }
 
+    /**
+     * The default method that can be called and extended to load entity data.
+     */
+    async load() { }
 
+    /**
+     * The default method that can be called and extended to destroy entity data.
+     */
+    async destroy() { }
 
-    async save() {
-        await this.call(A_TYPES__EntityBaseMethod.SAVE, {
-            entities: [
-                this
-            ]
-        });
-    }
+    /**
+     * The default method that can be called and extended to save entity data.
+     */
+    async save() { }
 
 
 

package/src/global/A-Entity/A-Entity.meta.ts

@@ -1,9 +1,10 @@
+import { A_TYPES__A_InjectDecorator_Meta } from "@adaas/a-concept/decorators/A-Inject/A-Inject.decorator.types";
 import { A_Meta } from "../A-Meta/A-Meta.class";
-import { A_TYPES__EntityMeta } from "./A-Entity.types";
+import { A_TYPES__EntityMeta, A_TYPES__EntityMetaKey } from "./A-Entity.types";
 
 
 export class A_EntityMeta extends A_Meta<A_TYPES__EntityMeta> {
 
-
+  
 
 }

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

@@ -9,7 +9,7 @@ import { A_TYPES__ContainerMeta_FeatureItem } from "../A-Container/A-Container.t
 export type A_TYPES__EntityCallParams<T extends string> = {
     name: T,
     fragments: Array<A_Fragment>,
-    entities: Array<A_Entity<any, any, any>>,
+    entities: Array<A_Entity<any, any>>,
     components: Array<{ new(...args: any[]): any }>
 }
 
@@ -73,6 +73,7 @@ export type A_TYPES__EntityMeta = {
 export enum A_TYPES__EntityMetaKey {
     EXTENSIONS = 'a-component-extensions',
     FEATURES = 'a-component-features',
+    ABSTRACTIONS = 'a-component-abstractions',
 }
 
 

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

@@ -1,15 +1,12 @@
+import { A_Context } from "../A-Context/A-Context.class";
 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, } from "./A-Feature.types";
 import { A_Error, A_TYPES__Required } from "@adaas/a-utils";
-import { A_Context } from "../A-Context/A-Context.class";
 import { A_TYPES__A_Feature_Extend } from "@adaas/a-concept/decorators/A-Feature/A-Feature.decorator.types";
 import { A_Stage } from "../A-Stage/A-Stage.class";
-import { A_TYPES__A_StageStep } from "../A-Stage/A-Stage.types";
 import { StepsManager } from "@adaas/a-concept/helpers/StepsManager.class";
 
-
-
 /**
  * A_Feature is representing a feature that can be executed across multiple components
  * This class stores the steps of the feature and executes them in order of appearance
@@ -48,10 +45,12 @@ export class A_Feature {
     result?: any
     error?: A_Error
 
+    readonly name: string;
 
     constructor(
         params: A_TYPES__Required<Partial<A_TYPES__FeatureConstructor>, ['steps']>
     ) {
+        this.name = params.name || this.constructor.name;
 
         this.SM = new StepsManager(params.steps);
 
@@ -175,11 +174,23 @@ export class A_Feature {
      * 
      */
     async process() {
-        this.state = A_TYPES__FeatureState.PROCESSING;
+        if (this.isDone()) {
+            return this.result;
+        }
+
+        try {
+            this.state = A_TYPES__FeatureState.PROCESSING;
+
+            for (const stage of this.stages) {
+                await stage.process();
+            }
+
+            await this.completed();
 
-        for (const stage of this) {
-            await stage.process();
+        } catch (error) {
+            await this.failed(error);
         }
+      
     }
 
 

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

@@ -1,12 +1,20 @@
-import { A_TYPES__A_InjectDecorator_Injectable, A_TYPES__A_InjectDecorator_Meta } from "@adaas/a-concept/decorators/A-Inject/A-Inject.decorator.types"
-import { A_Component } from "../A-Component/A-Component.class"
 import { A_TYPES__ScopeConfig, A_TYPES__ScopeConstructor } from "../A-Scope/A-Scope.types"
 import { A_TYPES__A_StageStep } from "../A-Stage/A-Stage.types"
+import { A_Fragment } from "../A-Fragment/A-Fragment.class"
+import { A_Entity } from "@adaas/a-concept/global/A-Entity/A-Entity.class"
 
 
 export type A_TYPES__FeatureIteratorReturn<T extends any = any> = () => Promise<T>
 
 
+export type A_TYPES__FeatureCallParams = {
+    fragments: Array<A_Fragment>,
+    entities: Array<A_Entity<any, any>>,
+    components: Array<{ new(...args: any[]): any }>
+}
+
+
+
 export type A_TYPES__FeatureConstructor = {
     steps: A_TYPES__A_StageStep[]
 } & A_TYPES__ScopeConstructor & A_TYPES__ScopeConfig

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

@@ -1,11 +1,3 @@
-// 
-// 
-// 
-// 
-// 
-// 
-
-
 /**
  * A Meta is an entity that stores all the metadata for the specific entity like container, component, feature, etc. 
  * 
@@ -185,4 +177,9 @@ export class A_Meta<
     clear(): void {
         this.meta.clear();
     }
+
+
+    toArray(): Array<[keyof _StorageItems, _StorageItems[keyof _StorageItems]]> {
+        return Array.from(this.meta.entries());
+    }
 }