@adaas/a-concept 0.0.64 → 0.1.1

package/src/helpers/{StepsManager.class.ts → A_StepsManager.class.ts}

@@ -1,8 +1,9 @@
 import { A_Feature } from "../global/A-Feature/A-Feature.class";
+import { A_TYPES__FeatureDefineDecoratorTemplateItem } from "../global/A-Feature/A-Feature.types";
 import { A_Stage } from "../global/A-Stage/A-Stage.class";
 import { A_TYPES__A_StageStep } from "../global/A-Stage/A-Stage.types";
 
-export class StepsManager {
+export class A_StepsManager {
 
     public entities: A_TYPES__A_StageStep[];
     public graph: Map<string, Set<string>>;
@@ -11,8 +12,9 @@ export class StepsManager {
     public sortedEntities: string[];
 
 
-    constructor(entities: A_TYPES__A_StageStep[]) {
-        this.entities = entities;
+    constructor(entities: Array<A_TYPES__FeatureDefineDecoratorTemplateItem>) {
+        this.entities = this.prepareSteps(entities);
+
         this.graph = new Map();
         this.visited = new Set();
         this.tempMark = new Set();
@@ -20,6 +22,20 @@ export class StepsManager {
 
     }
 
+    private prepareSteps(
+        entities: Array<A_TYPES__FeatureDefineDecoratorTemplateItem>
+    ): Array<A_TYPES__A_StageStep> {
+        return entities.map(step => {
+            return {
+                ...step,
+                
+                behavior: step.behavior || 'sync',
+                before: step.before || [],
+                after: step.after || [],
+            };
+        });
+    }
+
     private ID(step: A_TYPES__A_StageStep) {
         return `${typeof step.component === 'string' ? step.component : step.component.name}.${step.handler}`;
     }

package/src/helpers/A_TypeGuards.helper.ts

@@ -0,0 +1,318 @@
+import {
+    A_TYPES__Feature_Constructor,
+    A_TYPES__FeatureAvailableComponents,
+    A_TYPES__FeatureExtendDecoratorTarget
+} from "../global/A-Feature/A-Feature.types";
+import {
+    A_TYPES__Error_Constructor,
+    A_TYPES__Error_Init
+} from "../global/A-Error/A_Error.types";
+import { A_Component } from "../global/A-Component/A-Component.class";
+import { A_ComponentMeta } from "../global/A-Component/A-Component.meta";
+import { A_TYPES__Component_Constructor } from "../global/A-Component/A-Component.types";
+import { A_Container } from "../global/A-Container/A-Container.class";
+import { A_ContainerMeta } from "../global/A-Container/A-Container.meta";
+import { A_TYPES__Container_Constructor } from "../global/A-Container/A-Container.types";
+import { A_Entity } from "../global/A-Entity/A-Entity.class";
+import { A_EntityMeta } from "../global/A-Entity/A-Entity.meta";
+import { A_TYPES__Entity_Constructor } from "../global/A-Entity/A-Entity.types";
+import { A_Feature } from "../global/A-Feature/A-Feature.class";
+import { A_Fragment } from "../global/A-Fragment/A-Fragment.class";
+import { A_TYPES__Fragment_Constructor } from "../global/A-Fragment/A-Fragment.types";
+import { A_Scope } from "../global/A-Scope/A-Scope.class";
+import { A_Caller } from "../global/A-Caller/A_Caller.class";
+import { A_TYPES__Caller_Constructor } from "../global/A-Caller/A_Caller.types";
+import { A_Error } from "../global/A-Error/A_Error.class";
+import { A_CommonHelper } from "./A_Common.helper";
+import { A_TYPES__AbstractionAvailableComponents } from "../global/A-Abstraction/A-Abstraction.types";
+import { A_TYPES__Scope_Constructor } from "../global/A-Scope/A-Scope.types";
+import { A_TYPES__InjectableTargets } from "../global/A-Inject/A-Inject.types";
+
+
+
+export class A_TypeGuards {
+    // ===========================================================================
+    // ============================= BASE Type Guards ============================
+    // ===========================================================================
+    /**
+     * Check if value is a string
+     * 
+     * @param value 
+     * @returns 
+     */
+    static isString(value: any): value is string {
+        return typeof value === 'string' || value instanceof String;
+    }
+    /**
+     * Check if value is a number
+     * 
+     * @param value 
+     * @returns 
+     */
+    static isNumber(value: any): value is number {
+        return typeof value === 'number' && isFinite(value);
+    }
+    /**
+     * Check if value is a boolean
+     * 
+     * @param value 
+     * @returns 
+     */
+    static isBoolean(value: any): value is boolean {
+        return typeof value === 'boolean';
+    }
+    /**
+     * Check if value is an array
+     * 
+     * @param value 
+     * @returns 
+     */
+    static isArray(value: any): value is Array<any> {
+        return Array.isArray(value);
+    }
+    /**
+     * Check if value is an object
+     * 
+     * @param value 
+     * @returns 
+     */
+    static isObject<T extends Object = Object>(value: any): value is T {
+        return value && typeof value === 'object' && !Array.isArray(value);
+    }
+    /**
+     * Check if value is a function
+     * 
+     * @param value 
+     * @returns 
+     */
+    static isFunction(value: any): value is Function {
+        return typeof value === 'function';
+    }
+
+    static isUndefined(value: any): value is undefined {
+        return typeof value === 'undefined';
+    }
+
+    static isRegExp(value: any): value is RegExp {
+        return value instanceof RegExp;
+    }
+
+
+    // ===========================================================================
+    // ==========================A-Concept Type Guards ===========================
+    // ===========================================================================
+    /**
+     * Type guard to check if the constructor is of type A_Container
+     * 
+     * @param ctor 
+     * @returns 
+     */
+    static isContainerConstructor(ctor: any): ctor is A_TYPES__Container_Constructor {
+        return typeof ctor === 'function' && A_CommonHelper.isInheritedFrom(ctor, A_Container);
+    }
+    /**
+     * Type guard to check if the constructor is of type A_Component
+     * 
+     * @param ctor 
+     * @returns 
+     */
+    static isComponentConstructor(ctor: any): ctor is A_TYPES__Component_Constructor {
+        return typeof ctor === 'function' && A_CommonHelper.isInheritedFrom(ctor, A_Component);
+    }
+    /**
+     * Type guard to check if the constructor is of type A_Fragment
+     * 
+     * @param ctor 
+     * @returns 
+     */
+    static isFragmentConstructor(ctor: any): ctor is A_TYPES__Fragment_Constructor {
+        return typeof ctor === 'function' && A_CommonHelper.isInheritedFrom(ctor, A_Fragment);
+    }
+    /**
+     * Type guard to check if the constructor is of type A_Entity
+     * 
+     * @param ctor 
+     * @returns 
+     */
+    static isEntityConstructor(ctor: any): ctor is A_TYPES__Entity_Constructor {
+        return typeof ctor === 'function' && A_CommonHelper.isInheritedFrom(ctor, A_Entity);
+    }
+    /**
+     * Type guard to check if the constructor is of type A_Scope
+     * 
+     * @param ctor 
+     * @returns 
+     */
+    static isScopeConstructor(ctor: any): ctor is A_TYPES__Scope_Constructor {
+        return typeof ctor === 'function' && A_CommonHelper.isInheritedFrom(ctor, A_Scope);
+    }
+    /**
+     * Type guard to check if the constructor is of type A_Scope
+     * 
+     * @param ctor 
+     * @returns 
+     */
+    static isErrorConstructor(ctor: any): ctor is A_TYPES__Error_Constructor {
+        return typeof ctor === 'function' && A_CommonHelper.isInheritedFrom(ctor, A_Error);
+    }
+    /**
+     * Type guard to check if the constructor is of type A_Feature
+     * 
+     * @param ctor 
+     * @returns 
+     */
+    static isFeatureConstructor(ctor: any): ctor is A_TYPES__Feature_Constructor {
+        return typeof ctor === 'function' && A_CommonHelper.isInheritedFrom(ctor, A_Feature);
+    }
+    /**
+     * Type guard to check if the constructor is of type A_Caller
+     * 
+     * @param ctor 
+     * @returns 
+     */
+    static isCallerConstructor(ctor: any): ctor is A_TYPES__Caller_Constructor {
+        return typeof ctor === 'function' && A_CommonHelper.isInheritedFrom(ctor, A_Caller);
+    }
+    // ----------------------------------------------------------------------------
+    // Instance type guards
+    // ----------------------------------------------------------------------------
+    /**
+     * Type guard to check if the instance is of type A_Container
+     * 
+     * @param instance 
+     * @returns 
+     */
+    static isContainerInstance(instance: any): instance is A_Container {
+        return instance instanceof A_Container;
+    }
+    /**
+     * Type guard to check if the instance is of type A_Component
+     * 
+     * @param instance 
+     * @returns 
+     */
+    static isComponentInstance(instance: any): instance is A_Component {
+        return instance instanceof A_Component;
+    }
+
+    /**
+     * Type guard to check if the instance is of type A_Feature
+     * 
+     * @param instance 
+     * @returns 
+     */
+    static isFeatureInstance(instance: any): instance is A_Feature {
+        return instance instanceof A_Feature;
+    }
+    /**
+     * Type guard to check if the instance is of type A_Fragment
+     * 
+     * @param instance 
+     * @returns 
+     */
+    static isFragmentInstance(instance: any): instance is A_Fragment {
+        return instance instanceof A_Fragment;
+    }
+    /**
+     * Type guard to check if the instance is of type A_Entity
+     * 
+     * @param instance 
+     * @returns 
+     */
+    static isEntityInstance(instance: any): instance is A_Entity {
+        return instance instanceof A_Entity;
+    }
+    /**
+     * Type guard to check if the instance is of type A_Scope
+     * 
+     * @param instance 
+     * @returns 
+     */
+    static isScopeInstance(instance: any): instance is A_Scope {
+        return instance instanceof A_Scope;
+    }
+    /**
+     * Type guard to check if the instance is of type A_Error
+     * 
+     * @param instance 
+     * @returns 
+     */
+    static isErrorInstance(instance: any): instance is A_Error {
+        return instance instanceof A_Error;
+    }
+    /**
+     * Type guard to check if the instance is of type A_ComponentMeta
+     * 
+     * @param instance 
+     * @returns 
+     */
+    static isComponentMetaInstance(instance: any): instance is A_ComponentMeta {
+        return instance instanceof A_ComponentMeta;
+    }
+    /**
+     * Type guard to check if the instance is of type A_ContainerMeta
+     * 
+     * @param instance 
+     * @returns 
+     */
+    static isContainerMetaInstance(instance: any): instance is A_ContainerMeta {
+        return instance instanceof A_ContainerMeta;
+    }
+    /**
+     * Type guard to check if the instance is of type A_EntityMeta
+     * 
+     * @param instance 
+     * @returns 
+     */
+    static isEntityMetaInstance(instance: any): instance is A_EntityMeta {
+        return instance instanceof A_EntityMeta;
+    }
+
+
+
+    // ==========================================================================
+    // ========================= SPECIAL Type Guards =============================
+    // ===========================================================================
+    static isConstructorAvailableForAbstraction(target: any): target is A_TYPES__AbstractionAvailableComponents {
+        return A_TypeGuards.isContainerConstructor(target)
+            || A_TypeGuards.isComponentConstructor(target);
+    }
+
+
+    static isTargetAvailableForInjection(target: any): target is A_TYPES__InjectableTargets {
+        return A_TypeGuards.isComponentConstructor(target)
+            || A_TypeGuards.isComponentInstance(target)
+            || A_TypeGuards.isContainerInstance(target);
+    }
+
+    static isAllowedForFeatureCall(param: any): param is A_TYPES__FeatureAvailableComponents {
+        return A_TypeGuards.isContainerInstance(param)
+            || A_TypeGuards.isComponentInstance(param)
+            || A_TypeGuards.isEntityInstance(param);
+    }
+
+    static isAllowedForFeatureDefinition(param: any): param is A_TYPES__FeatureAvailableComponents {
+        return A_TypeGuards.isContainerInstance(param)
+            || A_TypeGuards.isComponentInstance(param)
+            || A_TypeGuards.isEntityInstance(param);
+    }
+
+    static isAllowedForFeatureExtension(param: any): param is A_TYPES__FeatureExtendDecoratorTarget {
+        return A_TypeGuards.isComponentInstance(param);
+    }
+
+    static isAllowedForAbstractionDefinition(param: any): param is A_TYPES__AbstractionAvailableComponents {
+        return A_TypeGuards.isContainerInstance(param)
+            || A_TypeGuards.isComponentInstance(param);
+    }
+
+    /**
+     * Allows to check if the provided param is of constructor type.
+     * 
+     * @param param 
+     * @returns 
+     */
+    static isConstructorType<T extends A_TYPES__Error_Init>(param: any): param is T {
+        return !!param && A_TypeGuards.isObject(param) && !(param instanceof Error) && "message" in param;
+    }
+}

package/src/types/A_Common.types.ts

@@ -0,0 +1,79 @@
+type Primitive = string | number | boolean | bigint | symbol | null | undefined;
+type Decrement = [never, 0, 1, 2, 3, 4, 5];
+
+export type A_TYPES__DeepPartial<T, D extends number = 5> = {
+    [P in keyof Required<T>]?:
+    [D] extends [never] ? any :
+
+    Required<T>[P] extends Array<infer U>
+    ? Array<A_TYPES__DeepPartial<U, Decrement[D]>>
+
+    : Required<T>[P] extends Function
+    ? Required<T>[P]
+
+    : Required<T>[P] extends object
+    ? A_TYPES__DeepPartial<T[P], Decrement[D]>
+    : T[P]
+};
+
+
+// export type A_TYPES__DeepPartial<T> = {
+//     [P in keyof Required<T>]?: Required<T>[P] extends object ? A_TYPES__DeepPartial<T[P]> : T[P];
+// };
+
+export type A_TYPES__ObjectKeyEnum<T, E> = {
+    [P in keyof Required<T>]?: T[P] extends object ? A_TYPES__ObjectKeyEnum<T[P], E> : E;
+};
+
+
+export type A_TYPES__Dictionary<T> = {
+    [Key: string]: T;
+}
+
+
+export type A_TYPES__NonObjectPaths<T> = T extends object ? { [K in keyof T]:
+    `${Exclude<K, symbol>}${""}`
+}[keyof T] : never
+
+
+
+
+export type A_TYPES__Paths<T, D extends number = 5> = [D] extends [never] ? never : (
+    T extends object ? { [K in keyof T]:
+        `${Exclude<K, symbol>}${"" | `.${A_TYPES__Paths<T[K], Decrement[D]>}`}`
+    }[keyof T] : never
+);
+
+export type A_TYPES__UnionToIntersection<U> =
+    (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+
+
+export type A_TYPES__PathsToObject<_Obj, T extends readonly string[]> = A_TYPES__UnionToIntersection<
+    {
+        [K in keyof T]: T[K] extends `${infer Key}.${infer Rest}`
+        ? { [P in Key]: P extends keyof _Obj
+            ? A_TYPES__PathsToObject<Required<_Obj>[P], [Rest]>
+            : any
+
+        }
+        : { [P in T[K]]:
+            `${T[K]}` extends keyof Required<_Obj> ? Required<_Obj>[`${T[K]}`] : never
+        };
+    }[number]
+>;
+
+export type A_TYPES__Required<T, arr extends (A_TYPES__Paths<T>)[] = (A_TYPES__Paths<T>)[]> = A_TYPES__PathsToObject<T, arr> & T;
+
+
+export type A_TYPES__ExtractNested<T, P extends string> = P extends `${infer K}.${infer Rest}`
+    ? K extends keyof T
+    ? { [Key in K]: A_TYPES__ExtractNested<T[K], Rest> }
+    : never
+    : P extends keyof T
+    ? { [Key in P]: T[P] }
+    : never;
+
+
+export type A_TYPES__ExtractProperties<T, P extends A_TYPES__Paths<T>[]> = A_TYPES__UnionToIntersection<{
+    [K in keyof P]: P[K] extends string ? A_TYPES__ExtractNested<T, P[K]> : never
+}[number]>;

package/tests/A-Common.test.ts

@@ -0,0 +1,117 @@
+import { A_CommonHelper } from "@adaas/a-concept/helpers/A_Common.helper";
+import { A_IdentityHelper } from "@adaas/a-concept/helpers/A_Identity.helper";
+import { A_TYPES__DeepPartial } from "@adaas/a-concept/types/A_Common.types";
+jest.retryTimes(0);
+
+describe('CommonHelper Tests', () => {
+    it('Deep Clone and  Merge ', async () => {
+
+        type TestType = {
+            a: string,
+            b: string,
+            c: {
+                d: string
+            },
+            f: (name: string) => string
+            s: Date
+        }
+
+        const t: TestType = {
+            a: 'a',
+            b: 'b',
+            c: {
+                d: 'd'
+            },
+            f: (name: string) => { return name },
+            s: new Date()
+        }
+
+        const t2: A_TYPES__DeepPartial<TestType> = {
+            a: 'aa',
+            c: {
+                d: 'dd'
+            },
+            f: (name: string) => { return name + '2' }
+        }
+
+        const merged = A_CommonHelper.deepCloneAndMerge(t2, t);
+
+
+        const name = merged.f('names');
+
+
+        expect(merged.a).toBe('aa');
+        expect(merged.b).toBe('b');
+        expect(merged.c.d).toBe('dd');
+        expect(name).toBe('names2');
+        expect(t).not.toEqual(merged);
+        expect(t2).not.toEqual(merged);
+    });
+
+    it('Deep Clone Different Types', async () => {
+
+        type TestType = {
+            a: string,
+            b: string,
+            c: {
+                d: string
+            },
+            bool:{
+                a: boolean
+            },
+            f: (name: string) => string
+            s: Date
+        }
+
+        const t: TestType = {
+            a: 'a',
+            b: 'b',
+            c: {
+                d: 'd'
+            },
+            bool:{
+                a: true
+            },
+            f: (name: string) => { return name },
+            s: new Date()
+        }
+
+        const t2: any = {
+            e: 'foo',
+            b: 'bb',
+            c:{
+                d: 'ddd'
+            },
+            bool:{
+                a: false
+            },
+            some: {
+                d: 'dd'
+            },
+        }
+
+        const merged = A_CommonHelper.deepCloneAndMerge(t2, t);
+
+        expect(merged.a).toBe('a');
+        expect(merged.b).toBe('bb');
+        expect(merged.c.d).toBe('ddd');
+        expect(merged.bool.a).toBe(false);
+        expect((merged as any).e).toBe('foo');
+        expect((merged as any).some.d).toBe('dd');
+        expect(merged.f('names')).toBe('names');
+    });
+    it('should generate and then parse Unique time based IDs', async () => {
+        const id = A_IdentityHelper.generateTimeId();
+        const parts = A_IdentityHelper.parseTimeId(id);
+
+        expect(id).toBeDefined();
+        expect(parts.timestamp).toBeInstanceOf(Date);
+        expect(parts.random).toHaveLength(6);
+
+        // Check that the timestamp is recent (within the last minute)
+        const now = Date.now();
+        const timestamp = parts.timestamp.getTime();
+        expect(timestamp).toBeLessThanOrEqual(now);
+        expect(timestamp).toBeGreaterThan(now - 60000); // within the last minute
+    });
+});

package/tests/A-Component.test.ts

@@ -1,6 +1,8 @@
+import { A_Inject } from '@adaas/a-concept/global/A-Inject/A-Inject.decorator';
 import './test.setup';
 
 import { A_Component } from "@adaas/a-concept/global/A-Component/A-Component.class";
+import { A_Context } from '@adaas/a-concept/global/A-Context/A-Context.class';
 
 jest.retryTimes(0);
 
@@ -10,18 +12,21 @@ describe('A-Component tests', () => {
         const component = new A_Component();
     });
     it('Should Allow to create a component with dependencies', async () => {
+        class MyComponent extends A_Component { }
+
         class DependentComponent extends A_Component {
             constructor(
-                public dependency: A_Component
+                @A_Inject(MyComponent) public dependency: MyComponent
             ) {
                 super();
             }
         }
 
-        const component = new A_Component();
-        const dependentComponent = new DependentComponent(component);
-        expect(dependentComponent.dependency).toBe(component);
-    });
-   
+        A_Context.root.register(MyComponent);
+        A_Context.root.register(DependentComponent);
 
+        const dependentComponent = A_Context.root.resolve(DependentComponent);
+
+        expect(dependentComponent.dependency).toBeInstanceOf(MyComponent);
+    });
 });