@adaas/a-concept 0.0.55 → 0.0.57

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

@@ -67,7 +67,7 @@ export type A_TYPES__A_StageStep = {
     /**
      * The component to be called
      */
-    component: typeof A_Component | A_Container
+    component: typeof A_Component | A_Container | string
 
     /**
      * The method to be called on the component

package/src/helpers/StepsManager.class.ts

@@ -21,7 +21,7 @@ export class StepsManager {
     }
 
     private ID(step: A_TYPES__A_StageStep) {
-        return `${step.component.name}.${step.handler}`;
+        return `${typeof step.component === 'string' ? step.component : step.component.name}.${step.handler}`;
     }
 
     private buildGraph() {
@@ -103,7 +103,7 @@ export class StepsManager {
                 stage.add(step);
             });
 
-        return stages.map(stage => new A_Stage(feature, stage.steps) );
+        return stages.map(stage => new A_Stage(feature, stage.steps));
     }
 }
 

package/tests/A-Command.test.ts

@@ -0,0 +1,130 @@
+
+
+
+import { A_CONSTANTS__A_Command_Status, A_CONSTANTS_A_Command_Features } from "@adaas/a-concept/base/A-Command/A_Command.constants";
+import { A_Command } from "@adaas/a-concept/base/A-Command/A_Command.entity";
+import { A_CommandContext } from "@adaas/a-concept/base/A-Command/context/A_Command.context";
+import { A_Inject } from "@adaas/a-concept/decorators/A-Inject/A-Inject.decorator";
+import { A_Component } from "@adaas/a-concept/global/A-Component/A-Component.class";
+import { A_Feature } from "@adaas/a-concept/global/A-Feature/A-Feature.class";
+import { A_Scope } from "@adaas/a-concept/global/A-Scope/A-Scope.class";
+import { A_Error } from "@adaas/a-utils";
+
+jest.retryTimes(0);
+
+describe('A-Command tests', () => {
+
+    it('Should Allow to create a command', async () => {
+        const command = new A_Command({});
+        expect(command).toBeInstanceOf(A_Command);
+        expect(command.Code).toBe('A_Command');
+        expect(command.id).toBeDefined();
+        expect(command.aseid).toBeDefined();
+        expect(command.Status).toBe(A_CONSTANTS__A_Command_Status.INITIALIZED);
+        expect(command.Scope).toBeInstanceOf(A_Scope);
+        expect(command.Scope.resolve(A_CommandContext)).toBeInstanceOf(A_CommandContext);
+    });
+    it('Should allow to execute a command', async () => {
+        const command = new A_Command({});
+
+        await command.execute();
+
+        expect(command.Status).toBe(A_CONSTANTS__A_Command_Status.COMPLETED);
+        expect(command.StartedAt).toBeInstanceOf(Date);
+        expect(command.EndedAt).toBeInstanceOf(Date);
+    });
+    it('Should allow to serialize and deserialize a command', async () => {
+        const command = new A_Command({});
+
+        await command.execute();
+
+        const serialized = command.toJSON();
+        expect(serialized).toBeDefined();
+        expect(serialized.aseid).toBe(command.aseid.toString());
+        expect(serialized.code).toBe(command.Code);
+        expect(serialized.status).toBe(command.Status);
+        expect(serialized.startedAt).toBe(command.StartedAt?.toISOString());
+        expect(serialized.duration).toBe(command.Duration);
+
+
+        const deserializedCommand = new A_Command(serialized);
+        expect(deserializedCommand).toBeInstanceOf(A_Command);
+        expect(deserializedCommand.aseid.toString()).toBe(command.aseid.toString());
+        expect(deserializedCommand.Code).toBe(command.Code);
+        expect(deserializedCommand.Status).toBe(command.Status);
+        expect(deserializedCommand.StartedAt?.toISOString()).toBe(command.StartedAt?.toISOString());
+        expect(deserializedCommand.Duration).toBe(command.Duration);
+    });
+    it('Should allow to execute a command with custom logic', async () => {
+
+        // 1) create a scope 
+        const scope = new A_Scope({ name: 'TestScope' });
+        // 2) create a new command 
+        type resultType = { bar: string };
+        type invokeType = { foo: string };
+        class MyCommand extends A_Command<invokeType, resultType> { }
+
+        // 3) create a custom component with custom logic
+        class MyComponent extends A_Component {
+
+            @A_Feature.Extend({ scope: [MyCommand] })
+            async [A_CONSTANTS_A_Command_Features.EXECUTE](
+                @A_Inject(A_CommandContext) context: A_CommandContext<resultType>
+            ) {
+                context.save('bar', 'baz');
+            }
+        }
+
+        // 4) register component in the scope
+        scope.register(MyComponent);
+
+        // 5) create a new command instance within the scope
+        const command = new MyCommand({ foo: 'bar' });
+        scope.register(command);
+
+        // 6) execute the command
+        await command.execute();
+
+        // 7) verify that command was executed with custom logic from MyComponent
+        expect(command.Status).toBe(A_CONSTANTS__A_Command_Status.COMPLETED);
+        expect(command.Result).toBeDefined();
+        expect(command.Result).toEqual({ bar: 'baz' });
+    })
+    it('Should allow to fail a command with custom logic', async () => {
+
+        // 1) create a scope 
+        const scope = new A_Scope({ name: 'TestScope' });
+        // 2) create a new command 
+        type resultType = { bar: string };
+        type invokeType = { foo: string };
+        class MyCommand extends A_Command<invokeType, resultType> { }
+
+        // 3) create a custom component with custom logic
+        class MyComponent extends A_Component {
+
+            @A_Feature.Extend({ scope: [MyCommand] })
+            async [A_CONSTANTS_A_Command_Features.EXECUTE](
+                @A_Inject(A_CommandContext) context: A_CommandContext<resultType>
+            ) {
+                context.error(new A_Error({ message: 'Test error' }));
+                //  it's optional to throw an error here, as the command may contain multiple errors that also can be a result of async operations
+                throw new A_Error({ message: 'Test error thrown' });
+            }
+        }
+
+        // 4) register component in the scope
+        scope.register(MyComponent);
+        // 5) create a new command instance within the scope
+        const command = new MyCommand({ foo: 'bar' });
+        scope.register(command);
+
+        // 6) execute the command
+        await command.execute();
+
+        // 7) verify that command was executed with custom logic from MyComponent
+        expect(command.Status).toBe(A_CONSTANTS__A_Command_Status.FAILED);
+        expect(command.Errors).toBeDefined();
+        expect(command.Errors?.size).toBe(1);
+        expect(Array.from(command.Errors?.values() || [])[0].message).toBe('Test error');
+    });
+});

package/tests/A-Component.test.ts

@@ -0,0 +1,25 @@
+import { A_Component } from "@adaas/a-concept/global/A-Component/A-Component.class";
+
+jest.retryTimes(0);
+
+describe('A-Component tests', () => {
+
+    it('Should Allow to create a component', async () => {
+        const component = new A_Component();
+    });
+    it('Should Allow to create a component with dependencies', async () => {
+        class DependentComponent extends A_Component {
+            constructor(
+                public dependency: A_Component
+            ) {
+                super();
+            }
+        }
+
+        const component = new A_Component();
+        const dependentComponent = new DependentComponent(component);
+        expect(dependentComponent.dependency).toBe(component);
+    });
+   
+
+});

package/tests/A-Entity.test.ts

@@ -0,0 +1,186 @@
+import { A_CONSTANTS__DEFAULT_ENV_VARIABLES } from "@adaas/a-concept/constants/env.constants";
+import { A_Entity } from "@adaas/a-concept/global/A-Entity/A-Entity.class";
+import { A_TYPES__Entity_JSON } from "@adaas/a-concept/global/A-Entity/A-Entity.types";
+import { A_Feature } from "@adaas/a-concept/global/A-Feature/A-Feature.class";
+import { ASEID } from "@adaas/a-utils";
+
+jest.retryTimes(0);
+
+describe('A-Entity tests', () => {
+    it('Should Allow to create an entity from undefined', async () => {
+        const entity = new A_Entity();
+    });
+    it('Should Allow to create an entity with Default ASEID', async () => {
+        const entity = new A_Entity();
+
+        expect(entity.aseid).toBeInstanceOf(ASEID);
+        expect(entity.aseid.scope).toBe('core');
+        expect(entity.aseid.namespace).toBe('a-concept');
+
+    });
+    it('Should Allow to create an entity with overridden ASEID Scope or Namespace', async () => {
+        class MyEntity extends A_Entity {
+            static get entity(): string {
+                return 'my-entity-test';
+            }
+
+            static get scope(): string {
+                return 'custom-scope';
+            }
+
+            static get namespace(): string {
+                return 'custom-namespace';
+            }
+        }
+
+        const entity = new MyEntity();
+
+        expect(entity.aseid).toBeInstanceOf(ASEID);
+        expect(entity.aseid.scope).toBe('custom-scope');
+        expect(entity.aseid.namespace).toBe('custom-namespace');
+        expect(entity.aseid.entity).toBe('my-entity-test');
+
+    });
+    it('Should Allow to create an entity with overridden ASEID Scope or Namespace from ENV Variables', async () => {
+        process.env[A_CONSTANTS__DEFAULT_ENV_VARIABLES.A_CONCEPT_DEFAULT_SCOPE] = 'env-scope';
+        process.env[A_CONSTANTS__DEFAULT_ENV_VARIABLES.A_CONCEPT_NAMESPACE] = 'env-namespace';
+
+        const entity = new A_Entity();
+
+        expect(entity.aseid).toBeInstanceOf(ASEID);
+        expect(entity.aseid.scope).toBe('env-scope');
+        expect(entity.aseid.namespace).toBe('env-namespace');
+
+        delete process.env[A_CONSTANTS__DEFAULT_ENV_VARIABLES.A_CONCEPT_DEFAULT_SCOPE];
+        delete process.env[A_CONSTANTS__DEFAULT_ENV_VARIABLES.A_CONCEPT_NAMESPACE];
+    });
+    it('Should Allow to create an entity from ASEID', async () => {
+        const entity = new A_Entity(
+            new ASEID({
+                namespace: 'default',
+                scope: 'default',
+                entity: 'entity-a',
+                id: Math.floor(Math.random() * 1000000000).toString(),
+            })
+        );
+    });
+    it('Should Allow to create an entity from string', async () => {
+        const entity = new A_Entity('default@default:entity-a:123456789');
+
+        expect(entity.aseid.toString()).toBe('default@default:entity-a:123456789');
+        expect(entity.aseid.id).toBe('123456789');
+    });
+    it('Should Allow to create an entity from object', async () => {
+
+        class MyEntity extends A_Entity<{ foo: string }, { foo: string } & A_TYPES__Entity_JSON> {
+            foo!: string;
+
+            fromNew(newEntity: { foo: string; }): void {
+                super.fromNew(newEntity);
+                this.aseid = new ASEID({
+                    namespace: 'default',
+                    scope: 'default',
+                    entity: 'entity-a',
+                    id: Math.floor(Math.random() * 1000000000).toString(),
+                });
+                this.foo = newEntity.foo;
+            }
+        }
+
+        const entity = new MyEntity({ foo: 'bar' });
+
+        expect(entity.foo).toBe('bar');
+    });
+    it('Should return an error when creating an entity from invalid string', async () => {
+        expect(() => {
+            const entity = new A_Entity('invalid-string');
+        }).toThrowError();
+    });
+    it('Should Allow to rewrite initializer method without changes to other methods', async () => {
+
+        class MyEntity extends A_Entity<{ foo: string }, { foo: string } & A_TYPES__Entity_JSON> {
+            foo!: string;
+
+            protected getInitializer(props?: string | { foo: string; } | ({ foo: string; } & A_TYPES__Entity_JSON) | ASEID | undefined): (props: any) => void | (() => void) {
+                if (typeof props === 'object' && props !== null && 'foo' in props) {
+                    return this.fromFoo.bind(this);
+                }
+                return super.getInitializer(props);
+            }
+
+
+            fromFoo(props: { foo: string; }): void {
+                this.foo = props.foo;
+            }
+
+            fromNew(newEntity: { foo: string; }): void {
+                super.fromNew(newEntity);
+                this.aseid = new ASEID({
+                    namespace: 'default',
+                    scope: 'default',
+                    entity: 'entity-a',
+                    id: Math.floor(Math.random() * 1000000000).toString(),
+                });
+                this.foo = 'not a bar';
+            }
+        }
+
+        const entity = new MyEntity({ foo: 'bar' });
+
+        expect(entity.foo).toBe('bar');
+    });
+
+    it('Should allow to define a feature on an entity', async () => {
+
+
+        class MyEntity extends A_Entity {
+            public foo!: string;
+
+
+            @A_Feature.Define()
+            async doSomething() { }
+        }
+
+    });
+    it('Should allow to serialize and deserialize an entity', async () => {
+
+        class MyEntity extends A_Entity<{ foo: string }, { foo: string } & A_TYPES__Entity_JSON> {
+            public foo!: string;
+
+            fromNew(newEntity: { foo: string; }): void {
+                this.aseid = new ASEID({
+                    namespace: 'default',
+                    scope: 'default',
+                    entity: 'entity-a',
+                    id: Math.floor(Math.random() * 1000000000).toString(),
+                });
+                this.foo = newEntity.foo;
+            }
+
+            fromJSON(serialized: { foo: string; } & A_TYPES__Entity_JSON): void {
+                this.aseid = new ASEID(serialized.aseid);
+                this.foo = serialized.foo;
+                return;
+            }
+
+            toJSON(): { foo: string } & A_TYPES__Entity_JSON {
+                return {
+                    ...super.toJSON(),
+                    foo: this.foo,
+                };
+            }
+        }
+
+        const entity = new MyEntity({ foo: 'baz' });
+        const aseid = entity.aseid.toString();
+
+        const serialized = entity.toJSON();
+        expect(serialized.foo).toBe('baz');
+
+        const entity2 = new MyEntity(serialized);
+        expect(entity2.foo).toBe('baz');
+        expect(entity2.aseid.toString()).toBe(aseid);
+        expect(entity2.aseid.toString()).toBe(entity.aseid.toString());
+    });
+
+});

package/tests/A-Feature.test.ts

@@ -0,0 +1,131 @@
+import { A_Inject } from "@adaas/a-concept/decorators/A-Inject/A-Inject.decorator";
+import { A_Component } from "@adaas/a-concept/global/A-Component/A-Component.class";
+import { A_Feature } from "@adaas/a-concept/global/A-Feature/A-Feature.class";
+import { A_FeatureCaller } from "@adaas/a-concept/global/A-Feature/A-FeatureCaller.class";
+import { A_Scope } from "@adaas/a-concept/global/A-Scope/A-Scope.class";
+
+jest.retryTimes(0);
+
+describe('A-Feature tests', () => {
+    it('Should Allow to create a feature from undefined', async () => {
+        const feature = new A_Feature({
+            name: 'TestFeature',
+            scope: new A_Scope({ name: 'TestScope' }),
+            steps: [],
+            caller: new A_Component()
+        });
+    });
+    it('Should Allow to create a feature with steps', async () => {
+        const feature = new A_Feature({
+            name: 'TestFeature',
+            scope: new A_Scope({ name: 'TestScope' }),
+            steps: [
+                {
+                    name: 'A_Component.testHandler',
+                    component: A_Component,
+                    handler: 'testHandler',
+                    behavior: 'sync',
+                    before: [],
+                    after: []
+                }
+            ],
+            caller: new A_Component()
+        });
+    });
+    it('Should be possible to execute a feature with steps as a template on the component', async () => {
+        // 1) create a base component with some feature
+        class MyExtendedComponent extends A_Component {
+
+            async testHandler(
+                @A_Inject(A_FeatureCaller) caller: MyComponent
+            ) {
+                caller.sum = 2;
+            }
+        }
+
+        // 2) create a custom component with a defined template feature
+        class MyComponent extends A_Component {
+            sum: number = 0;
+
+            @A_Feature.Define({
+                invoke: true,
+                template: [{
+                    name: 'MyExtendedComponent.testHandler',
+                    component: MyExtendedComponent,
+                    handler: 'testHandler',
+                    behavior: 'sync',
+                    before: [],
+                    after: []
+                }]
+            })
+            async testHandler() { }
+        }
+
+
+        // 3) create a running scope 
+        const scope = new A_Scope({ name: 'TestScope' });
+        scope.register(MyExtendedComponent);
+        scope.register(MyComponent);
+
+        // 4) create an instance of the component from the scope
+        const myComponent = scope.resolve(MyComponent);
+        expect(myComponent).toBeInstanceOf(MyComponent);
+        expect(myComponent.sum).toBe(0);
+
+        // 5) call the feature caller to execute the feature
+        await myComponent.testHandler();
+
+        // 6) check the results
+        expect(myComponent.sum).toBe(2);
+
+    });
+   it('Should be possible to execute a feature with steps as a template on the component with string component declaration', async () => {
+        // 1) create a base component with some feature
+        class MyExtendedComponent2 extends A_Component {
+
+            async testHandler(
+                @A_Inject(A_FeatureCaller) caller: MyComponent2
+            ) {
+                caller.sum = 2;
+            }
+        }
+
+        // 2) create a custom component with a defined template feature
+        class MyComponent2 extends A_Component {
+            sum: number = 0;
+
+            @A_Feature.Define({
+                invoke: true,
+                template: [{
+                    name: 'MyExtendedComponent2.testHandler',
+                    component: 'MyExtendedComponent2',
+                    handler: 'testHandler',
+                    behavior: 'sync',
+                    before: [],
+                    after: []
+                }]
+            })
+            async testHandler() { }
+        }
+
+
+        // 3) create a running scope 
+        const scope = new A_Scope({ name: 'TestScope' });
+        scope.register(MyExtendedComponent2);
+        scope.register(MyComponent2);
+
+        // 4) create an instance of the component from the scope
+        const myComponent = scope.resolve(MyComponent2);
+        expect(myComponent).toBeInstanceOf(MyComponent2);
+        expect(myComponent.sum).toBe(0);
+
+        // 5) call the feature caller to execute the feature
+        await myComponent.testHandler();
+
+        // 6) check the results
+        expect(myComponent.sum).toBe(2);
+
+    });
+
+
+});

package/tests/A-Scope.test.ts

@@ -0,0 +1,163 @@
+import { A_Component } from "@adaas/a-concept/global/A-Component/A-Component.class";
+import { A_Entity } from "@adaas/a-concept/global/A-Entity/A-Entity.class";
+import { A_Scope } from "@adaas/a-concept/global/A-Scope/A-Scope.class";
+import { ASEID } from "@adaas/a-utils";
+
+jest.retryTimes(0);
+
+describe('A-Scope tests', () => {
+
+    it('Should Allow to create a scope', async () => {
+        const scope = new A_Scope({ name: 'TestScope' });
+    });
+    it('Should allow to register a component', async () => {
+        const component = new A_Component();
+        const scope = new A_Scope({ name: 'TestScope' });
+        scope.register(component);
+
+    });
+    it('Should allow to resolve a component', async () => {
+        const component = new A_Component();
+        const scope = new A_Scope({ name: 'TestScope' });
+        scope.register(component);
+
+        const resolved = scope.resolve(A_Component);
+        expect(resolved).toBe(component);
+    });
+    it('Should return an error when resolving a non-registered component', async () => {
+        const scope = new A_Scope({ name: 'TestScope' });
+        expect(() => scope.resolve(A_Component)).toThrowError();
+    });
+    it('Should allow to register and resolve a component with dependencies', async () => {
+        class DependentComponent extends A_Component {
+            constructor(
+                public dependency: A_Component
+            ) {
+                super();
+            }
+        }
+
+        const component = new A_Component();
+        const scope = new A_Scope({ name: 'TestScope' });
+        scope.register(component);
+        scope.register(new DependentComponent(component));
+
+        const resolved = scope.resolve(DependentComponent);
+        expect(resolved).toBeInstanceOf(DependentComponent);
+        expect(resolved.dependency).toBe(component);
+    });
+
+    it('should resolve component registered in parent scope', async () => {
+        const parentScope = new A_Scope({ name: 'ParentScope' });
+        const childScope = new A_Scope({ name: 'ChildScope'});
+
+        childScope.parent(parentScope);
+
+        const component = new A_Component();
+        parentScope.register(component);
+
+        const resolved = childScope.resolve(A_Component);
+        expect(resolved).toBe(component);
+    });
+
+    it('Should resolve only one entity if no query is provided', async () => {
+        class MyEntity extends A_Entity<{ bar: string }> {
+            public bar!: string;
+            fromNew(newEntity: { bar: string; }): void {
+                this.aseid = new ASEID({
+                    namespace: 'default',
+                    scope: 'default',
+                    entity: 'entity-a',
+                    id: Math.floor(Math.random() * 1000000000).toString(),
+                })
+                this.bar = newEntity.bar;
+            }
+        }
+
+
+        const scope = new A_Scope({ name: 'TestScope' });
+        const entity1 = new MyEntity({ bar: 'bar' });
+        const entity2 = new MyEntity({ bar: 'baz' });
+        scope.register(entity1);
+        scope.register(entity2);
+        const resolved = scope.resolve(MyEntity);
+        expect(resolved).toBe(entity1);
+
+    });
+    it('Should resolve entities based on a query', async () => {
+        class MyEntity extends A_Entity<{ bar: string }> {
+            public bar!: string;
+            fromNew(newEntity: { bar: string; }): void {
+                this.aseid = new ASEID({
+                    namespace: 'default',
+                    scope: 'default',
+                    entity: 'entity-a',
+                    id: Math.floor(Math.random() * 1000000000).toString(),
+                })
+                this.bar = newEntity.bar;
+            }
+        }
+
+        const scope = new A_Scope({ name: 'TestScope' });
+        const entity1 = new MyEntity({ bar: 'bar' });
+        const entity2 = new MyEntity({ bar: 'baz' });
+        scope.register(entity1);
+        scope.register(entity2);
+        const resolved = scope.resolve(MyEntity, { query: { bar: 'baz' } });
+        expect(resolved).toBe(entity2);
+
+
+    });
+    it('Should return array if pagination.count is provided', async () => {
+        class MyEntity extends A_Entity<{ foo: string }> {
+            public foo!: string;
+            fromNew(newEntity: { foo: string; }): void {
+                this.aseid = new ASEID({
+                    namespace: 'default',
+                    scope: 'default',
+                    entity: 'entity-a',
+                    id: Math.floor(Math.random() * 1000000000).toString(),
+                })
+                this.foo = newEntity.foo;
+            }
+        }
+        const scope = new A_Scope({ name: 'TestScope' });
+        for (let i = 0; i < 10; i++) {
+            const entity = new MyEntity({ foo: 'bar' });
+            scope.register(entity);
+        }
+        const resolved = scope.resolve(MyEntity, { pagination: { count: 10 } });
+        expect(Array.isArray(resolved)).toBe(true);
+    });
+    it('Should return array with pagination.count and provided filter', async () => {
+        class MyEntity extends A_Entity<{ foo: string }> {
+            public foo!: string;
+            fromNew(newEntity: { foo: string; }): void {
+                this.aseid = new ASEID({
+                    namespace: 'default',
+                    scope: 'default',
+                    entity: 'entity-a',
+                    id: Math.floor(Math.random() * 1000000000).toString(),
+                })
+                this.foo = newEntity.foo;
+            }
+        }
+        const scope = new A_Scope({ name: 'TestScope' });
+        for (let i = 0; i < 5; i++) {
+            const entity = new MyEntity({ foo: 'bar' });
+            scope.register(entity);
+        }
+        for (let i = 0; i < 5; i++) {
+            const entity = new MyEntity({ foo: 'baz' });
+            scope.register(entity);
+        }
+        const resolved = scope.resolve(MyEntity, { query: { foo: 'baz' }, pagination: { count: 10 } });
+        expect(Array.isArray(resolved)).toBe(true);
+        expect((resolved as Array<MyEntity>).length).toBe(5);
+        (resolved as Array<MyEntity>).forEach(r => {
+            expect(r.foo).toBe('baz');
+        });
+
+    });
+
+});

package/dist/src/constants/A_ConceptLifecycle.constants.js

@@ -1,11 +0,0 @@
-"use strict";
-// import { A_TYPES__ConceptLifecycle_MethodDeclarationConfig } from "../decorators/A-ConceptLifecycle/A-ConceptLifecycle.decorator.types";
-// export const A_CONSTANTS__DEFAULT_CONCEPT_LIFECYCLE_METHOD_DECLARATION_CONFIG: A_TYPES__ConceptLifecycle_MethodDeclarationConfig = {
-//     name: '',
-//     behavior: 'sync',
-//     type: 'extension',
-//     after: [],
-//     before: [],
-//     override: []
-// } 
-//# sourceMappingURL=A_ConceptLifecycle.constants.js.map

package/dist/src/constants/A_ConceptLifecycle.constants.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"A_ConceptLifecycle.constants.js","sourceRoot":"","sources":["../../../src/constants/A_ConceptLifecycle.constants.ts"],"names":[],"mappings":";AAAA,2IAA2I;AAI3I,uIAAuI;AACvI,gBAAgB;AAChB,wBAAwB;AACxB,yBAAyB;AACzB,iBAAiB;AACjB,kBAAkB;AAClB,mBAAmB;AACnB,KAAK"}