@adaas/a-concept 0.0.3 → 0.0.5

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

@@ -0,0 +1,40 @@
+import { A_TYPES__ConceptStage } from "../A-Concept/A_Concept.types";
+import { A_Fragment } from "../A-Fragment/A-Fragment.class";
+import { A_TYPES__ScopeConstructor } from "../A-Scope/A-Scope.types";
+
+
+
+export type A_TYPES__ContainerConstructor<_Exports extends Array<String>> = {
+    name?: string,
+    exports: _Exports,
+} & A_TYPES__ScopeConstructor
+
+
+export type A_TYPES__ContainerCallParams<T extends string> = {
+    name: T,
+    fragments: Array<A_Fragment>,
+    components: Array<{ new(...args: any[]): any }>
+}
+
+export type A_TYPES__ContainerMeta = {
+    [A_TYPES__ContainerMetaKey.FEATURES]: Map<string, A_TYPES__ContainerMeta_FeatureItem>
+    [A_TYPES__ContainerMetaKey.STAGES]: Map<string, A_TYPES__ContainerMeta_StageExtension>
+}
+
+
+export enum A_TYPES__ContainerMetaKey {
+    FEATURES = 'a-container-features',
+    STAGES = 'a-container-stages',
+}
+
+export type A_TYPES__ContainerMeta_StageExtension = {
+    name: A_TYPES__ConceptStage,
+    handler: string,
+}
+
+
+export type A_TYPES__ContainerMeta_FeatureItem = {
+    name: string,
+    container: string,
+    handler: string,
+}

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

@@ -1,6 +1,14 @@
-import { A_CommonHelper, A_Polyfills } from "@adaas/a-utils";
-import { A_Namespace } from "../A-Namespace/A_Namespace.class";
+import { A_CommonHelper, A_Polyfills, A_TYPES__Dictionary } 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";
+import { A_Container } from "../A-Container/A-Container.class";
+import { A_Scope } from "../A-Scope/A-Scope.class";
+import { A_TYPES__ScopeConfig, A_TYPES__ScopeConstructor } from "../A-Scope/A-Scope.types";
+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";
 
 
 /**
@@ -12,36 +20,36 @@ import { A_Component } from "../A-Component/A-Component.class";
  */
 export class A_Context {
 
-
     static instance: A_Context;
 
     /**
-     * Stores all the Namespaces by namespace.
-     * There might be a Namespaces of the same type but with different namespaces.
-     * That might be useful for the cases when you need to have multiple instances of the same Namespace e.g.
-     * - multiple http servers
-     * - multitenant applications
-     * - etc.
+     * A set of globally registered containers.
+     */
+    protected containers: WeakMap<A_Container<any>, A_Scope> = new WeakMap();
+
+    /**
+     * A set of globally registered features.
      */
-    namespaced: Map<string, A_Namespace> = new Map();
+    protected features: WeakMap<A_Feature, A_Scope> = new WeakMap();
 
     /**
-     * Stores the singleton Namespaces. 
-     * Singleton Namespaces are the Namespaces that are used only once in the program.
-     * In most cases, the singleton Namespace is the main Namespace of the program.
-     * It could be :
-     * - the main Namespace of the Program
-     * - the authentication Namespace
-     * - the main database Namespace
-     * - etc.
+     * A set of globally registered concepts.
      */
-    singleton: WeakMap<{ new(...args: any[]): A_Namespace }, A_Namespace> = new WeakMap();
+    protected concepts: WeakMap<A_Concept<any>, A_Scope> = new WeakMap();
+
 
 
     /**
-     * Stores the components that are used in the program.
+     * A set of allocated scopes per every element in the program.
      */
-    components: Map<string, any> = new Map();
+    // protected scopes: WeakMap<A_Container<any> | A_Feature | A_Component | any, A_Scope> = new WeakMap();
+
+    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_Container.constructor, A_ComponentMeta> = new Map();
+    // uses to allow to store custom meta data
+    protected customMeta: Map<typeof A_Container.constructor, A_Meta<any>> = new Map();
+
 
     /**
      * Root Namespace is a Namespace that is used to run the program.
@@ -49,9 +57,15 @@ export class A_Context {
     private _root!: string
 
 
-    private constructor() {
+    private constructor() { }
+
+
+
+    // ===================================================================================================
+    // ================================ META OPERATIONS ==================================================
+    // ===================================================================================================
+
 
-    }
 
     /**
      * Get the instance of the Namespace Provider.
@@ -74,157 +88,246 @@ export class A_Context {
         return A_Polyfills.env;
     }
 
-    /**
-     * Register a Namespace in the provider.
-     * @param Namespace 
-     */
-    static register(Namespace: A_Namespace): string
-    static register(
-        Namespace: A_Namespace,
-        namespace?: string
-    ): string
-    static register(
-        param1: A_Namespace,
-        param2?: A_Namespace | string,
-    ): string {
+
+
+
+    static allocate(
+        component: any,
+        importing: Partial<A_TYPES__ScopeConstructor & A_TYPES__ScopeConfig>
+    ): A_Scope
+    static allocate(
+        feature: A_Feature,
+        importing: Partial<A_TYPES__ScopeConstructor & A_TYPES__ScopeConfig>
+    ): A_Scope
+    static allocate(
+        container: A_Container<any>,
+        importing: Partial<A_TYPES__ScopeConstructor & A_TYPES__ScopeConfig>
+    ): A_Scope
+    static allocate(
+        param1: A_Container<any> | A_Feature | A_Component | any,
+        param2: Partial<A_TYPES__ScopeConstructor & A_TYPES__ScopeConfig>
+    ): A_Scope {
 
         const instance = this.getInstance();
 
-        let Namespace: A_Namespace;
-        let namespace: string;
+        const newScope = new A_Scope(param2, param2);
 
-        if (typeof param2 === 'string') {
-            namespace = param2;
-            Namespace = param1;
-        } else {
-            Namespace = param1 as A_Namespace;
-            namespace = Namespace.name;
-        }
+        switch (true) {
+            case param1 instanceof A_Container:
+                instance.containers.set(param1, newScope);
+                break;
 
-        /**
-         * If the namespace is not provided, then use the root namespace.
-         * If the root namespace is not provided, then use the default namespace.
-         */
-        if (!namespace)
-            namespace = this.root
-                || process.env.ADAAS_NAMESPACE
-                || process.env.A_NAMESPACE
-                || process.env.ADAAS_APP_NAMESPACE
-                || 'a-concept'
+            case param1 instanceof A_Feature:
+                instance.features.set(param1, newScope);
+                break;
 
+            case param1 instanceof A_Concept:
+                instance.concepts.set(param1, newScope);
+                break;
 
 
-        if (!this.root)
-            instance._root = namespace;
+            default:
+                throw new Error(`[!] A-Concept Context: Unknown type of the parameter.`);
+        }
 
-        instance.namespaced.set(namespace, Namespace);
 
-        return namespace;
+        return newScope;
     }
 
 
 
 
+    static meta(
+        container: typeof A_Container,
+    ): A_ContainerMeta
+    static meta(
+        container: A_Container<any>,
+    ): A_ContainerMeta
+    static meta(
+        component: typeof A_Component,
+    ): A_ComponentMeta
+    static meta(
+        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: typeof A_Container | A_Container<any> | { new(...args: any[]): any } | A_Component | typeof A_Component,
+    ): A_ContainerMeta | A_ComponentMeta | A_Meta<T> {
+        const instance = this.getInstance();
 
+        let metaStorage: WeakMap<typeof A_Container.constructor, A_Meta<any>>;
+        let property: Function;
 
-    /**
-     * Get the Namespace by namespace.
-     * @param namespace 
-     */
-    static get(namespace: string) {
-        const instance = this.getInstance();
+        let meta: A_Meta<any>;
 
-        return instance.namespaced.get(namespace)
-    }
 
+        switch (true) {
+            case param1 instanceof A_Container: {
 
+                metaStorage = instance.containersMeta;
+                property = param1.constructor;
 
 
+                if (!metaStorage.has(property)) {
+                    const inheritMeta = metaStorage.get(Object.getPrototypeOf(property)) || new A_ContainerMeta();
+                    metaStorage.set(property, new A_ContainerMeta().from(inheritMeta));
+                }
 
-    /**
-     * Resolve the Component by Class. 
-     * 
-     * @param component 
-     */
-    static resolve<T extends A_Component>(
-        component: { new(...args: any[]): T }
-    ): T
-    static resolve<T extends A_Namespace>(
-        namespace: { new(...args: any[]): T }
-    ): T
-    static resolve<
-        T extends A_Namespace,
-    >(
-        namespaces: Array<{ new(...args: any[]): T }>
-    ): Array<T>
-    static resolve<T extends A_Namespace>(
-        namespace: { new(...args: any[]): T },
-        name: string
-    ): T
-    static resolve<
-        T extends A_Namespace,
-        K extends A_Component,
-    >(
-        param1: { new(...args: any[]): T } | { new(...args: any[]): K } | Array<{ new(...args: any[]): T }>,
-        param2?: string
-    ): T | K | Array<T> {
+                meta = metaStorage.get(property)!;
 
-        switch (true) {
+                break;
+            }
 
-            // If the first parameter is a Namespace 
-            case Array.isArray(param1) && param1.every(namespace => A_CommonHelper.isInheritedFrom(namespace, A_Namespace)):
-                return param1.map(namespace => this.resolveNamespace(namespace));
+            case A_CommonHelper.isInheritedFrom(param1, A_Container): {
+                metaStorage = instance.containersMeta;
+                property = param1 as typeof A_Container<any>;
 
-            // If the first parameter is a Namespace and the second parameter is a string
-            case !!param2 && typeof param1 === 'function' && A_CommonHelper.isInheritedFrom(param1, A_Namespace):
-                return this.resolveNamespace(param1 as typeof A_Namespace, param2) as T;
+                if (!metaStorage.has(property)) {
+                    const inheritMeta = metaStorage.get(Object.getPrototypeOf(property)) || new A_ContainerMeta();
+                    metaStorage.set(property, new A_ContainerMeta().from(inheritMeta));
+                }
 
-            // If the first parameter is a Component
-            case !!param2 && typeof param1 === 'function' && A_CommonHelper.isInheritedFrom(param1, A_Component):
-                return this.resolveComponent(param1 as { new(...args: any[]): A_Component }) as K;
+                meta = metaStorage.get(property)!;
 
-            default:
-                throw new Error(`[!] A-Concept Context: Unknown type of the parameter.`);
+                break;
+            }
+
+            case param1 instanceof A_Component: {
+                metaStorage = instance.componentsMeta;
+                property = param1.constructor;
+
+
+                if (!metaStorage.has(property)) {
+                    const inheritMeta = metaStorage.get(Object.getPrototypeOf(property)) || new A_ComponentMeta();
+                    metaStorage.set(property, new A_ComponentMeta().from(inheritMeta));
+                }
+
+                meta = metaStorage.get(property)!;
+
+                break;
+            }
+
+            case A_CommonHelper.isInheritedFrom(param1, A_Component): {
+                metaStorage = instance.componentsMeta;
+                property = param1 as typeof A_Component;
+
+
+                if (!metaStorage.has(property)) {
+                    const inheritMeta = metaStorage.get(Object.getPrototypeOf(property)) || new A_ComponentMeta();
+                    metaStorage.set(property, new A_ComponentMeta().from(inheritMeta));
+                }
+
+                meta = metaStorage.get(property)!;
+
+                break;
+            }
+
+            default: {
+                metaStorage = instance.customMeta;
+                property = typeof (param1 as any) === 'function' ? param1 : param1.constructor;
+
+                if (!metaStorage.has(property)) {
+                    const inheritMeta = metaStorage.get(Object.getPrototypeOf(property)) || new A_Meta();
+                    metaStorage.set(property, new A_Meta().from(inheritMeta));
+                }
+
+                meta = metaStorage.get(property)!;
+
+                break;
+            }
         }
+
+        // const inheritMeta: T = metaStorage.get(Object.getPrototypeOf(property))  || new A_Meta() as T;
+        // // we just know that the type of parent meta is the same as the type of the current meta
+        // const meta = metaStorage.get(property);
+
+        return meta!;
     }
 
 
 
-    private static resolveComponent<T extends A_Component>(
-        component: { new(...args: any[]): T }
-    ): T {
+
+
+    static scope(
+        concept: A_Concept
+    ): A_Scope
+    static scope(
+        component: A_Container<any>
+    ): A_Scope
+    static scope(
+        component: A_Feature
+    ): A_Scope
+    static scope(
+        param1: A_Feature | A_Container<any> | A_Concept
+    ): A_Scope | undefined {
+
         const instance = this.getInstance();
 
-        return instance.components.get(component.name) as T;
+        switch (true) {
+            case param1 instanceof A_Container:
+                return instance.containers.get(param1);
+
+            case param1 instanceof A_Feature:
+                return instance.features.get(param1);
+
+
+            case param1 instanceof A_Concept:
+                return instance.concepts.get(param1);
+
+            default:
+                throw new Error(`[!] A-Concept Context: Unknown type of the parameter.`);
+        }
     }
 
 
 
     /**
-     * 
-     * Allowing to resolve the Namespace by Class and Name.
-     * 
-     * @param namespace 
-     * @param name 
+     * Register a Namespace in the provider.
+     * @param Namespace 
      */
-    private static resolveNamespace<T extends A_Namespace>(
-        namespace: { new(...args: any[]): T },
-        name: string
-    ): T
-    private static resolveNamespace<T extends A_Namespace>(
-        namespace: { new(...args: any[]): T }
-    ): T
-    private static resolveNamespace<T extends A_Namespace>(
-        param1: { new(...args: any[]): T },
-        param2?: string
-    ): T {
+    static register(Namespace: A_Fragment): string
+    static register(
+        Namespace: A_Fragment,
+        namespace?: string
+    ): string
+    static register(
+        param1: A_Fragment,
+        param2?: A_Fragment | string,
+    ): string {
+
         const instance = this.getInstance();
 
-        return instance.namespaced.get(
-            param2 || param1.name
-        ) as T;
-    }
+        let fragment: A_Fragment;
+        let name: string;
+
+        if (typeof param2 === 'string') {
+            name = param2;
+            fragment = param1;
+        } else {
+            fragment = param1 as A_Fragment;
+            name = fragment.name;
+        }
+
+        /**
+         * If the namespace is not provided, then use the root namespace.
+         * If the root namespace is not provided, then use the default namespace.
+         */
+        if (!name)
+            name = this.root
+                || process.env.ADAAS_NAMESPACE
+                || process.env.A_NAMESPACE
+                || process.env.ADAAS_APP_NAMESPACE
+                || 'a-concept'
+
 
 
+        if (!this.root)
+            instance._root = name;
+
+        // instance.namedFragments.set(namespace, Namespace);
 
+        return name;
+    }
 }

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

@@ -0,0 +1,15 @@
+import { A_Scope } from "../A-Scope/A-Scope.class"
+
+
+
+export type A_TYPES__ContextExecutionPipeline = {
+    scope: A_Scope
+    steps: A_TYPES__ContextExecutionPipelineStep[]
+}
+
+
+export type A_TYPES__ContextExecutionPipelineStep = {
+    component: { new(...args: any[]): any },
+    handler: string,
+    args: any[]
+}

package/src/global/A-Dependency/A-DependencyReference.class.ts

@@ -1,61 +1,61 @@
-class RealDependency {
-    constructor(private name: string) { }
-
-    getName() {
-        return this.name;
-    }
-
-    performAction() {
-        console.log(`${this.name} is performing an action.`);
-    }
-}
-
-class DependencyReference<T> {
-    private proxyInstance: T | null = null;
-    private realInstance: T | null = null;
-
-    constructor(private realClass: { new(...args: any[]): T }, private args: any[]) { }
-
-    // Simulate async loading (e.g., dynamic imports, API calls, etc.)
-    private async loadInstance(): Promise<T> {
-        if (!this.realInstance) {
-            console.log('Loading real dependency...');
-            // Simulate async loading with a delay
-            await new Promise((resolve) => setTimeout(resolve, 1000));
-            this.realInstance = new this.realClass(...this.args);
-        }
-        return this.realInstance;
-    }
-
-    public async resolve(): Promise<T> {
-        if (!this.proxyInstance) {
-            const realInstance = await this.loadInstance();
-
-            this.proxyInstance = new Proxy({}, {
-                get: (target, prop) => {
-                    const value = (realInstance as any)[prop];
-
-                    // If the property is a method, return a bound function
-                    if (typeof value === 'function') {
-                        return value.bind(realInstance);
-                    }
-                    return value;
-                }
-            }) as T;
-        }
-
-        return this.proxyInstance;
-    }
-}
-
-
-// Example usage:
-(async () => {
-    const lazyDependency = new DependencyReference(RealDependency, ['ComponentA']);
-
-    const proxy = await lazyDependency.resolve();  // Loads the instance asynchronously
-
-    proxy.performAction();  // Will call the method on the real instance
-
-    console.log(proxy.getName());  // Calls method on the real instance
-})();
+// class RealDependency {
+//     constructor(private name: string) { }
+
+//     getName() {
+//         return this.name;
+//     }
+
+//     performAction() {
+//         console.log(`${this.name} is performing an action.`);
+//     }
+// }
+
+// class DependencyReference<T> {
+//     private proxyInstance: T | null = null;
+//     private realInstance: T | null = null;
+
+//     constructor(private realClass: { new(...args: any[]): T }, private args: any[]) { }
+
+//     // Simulate async loading (e.g., dynamic imports, API calls, etc.)
+//     private async loadInstance(): Promise<T> {
+//         if (!this.realInstance) {
+//             console.log('Loading real dependency...');
+//             // Simulate async loading with a delay
+//             await new Promise((resolve) => setTimeout(resolve, 1000));
+//             this.realInstance = new this.realClass(...this.args);
+//         }
+//         return this.realInstance;
+//     }
+
+//     public async resolve(): Promise<T> {
+//         if (!this.proxyInstance) {
+//             const realInstance = await this.loadInstance();
+
+//             this.proxyInstance = new Proxy({}, {
+//                 get: (target, prop) => {
+//                     const value = (realInstance as any)[prop];
+
+//                     // If the property is a method, return a bound function
+//                     if (typeof value === 'function') {
+//                         return value.bind(realInstance);
+//                     }
+//                     return value;
+//                 }
+//             }) as T;
+//         }
+
+//         return this.proxyInstance;
+//     }
+// }
+
+
+// // Example usage:
+// (async () => {
+//     const lazyDependency = new DependencyReference(RealDependency, ['ComponentA']);
+
+//     const proxy = await lazyDependency.resolve();  // Loads the instance asynchronously
+
+//     proxy.performAction();  // Will call the method on the real instance
+
+//     console.log(proxy.getName());  // Calls method on the real instance
+// })();