feat: add classic scope, singleton and lifecycles

lib/compiler/types.ts

@@ -160,6 +160,41 @@ export class Component {
 }
 
 export class ClassicComponent extends Component {
+  public get meta(): {
+    singleton?: boolean;
+    scope?: string;
+  } {
+    const meta: {
+      singleton?: boolean;
+      scope?: string;
+    } = {
+      singleton: undefined,
+      scope: undefined
+    };
+
+    const component = getDecorator('component', this.type);
+    if (component) {
+      const parameters = getDecoratorParameters(component);
+      if (
+        parameters.length > 0 &&
+        ts.isObjectLiteralExpression(parameters[0])
+      ) {
+        const config = parameters[0] as ts.ObjectLiteralExpression;
+
+        meta.singleton = isSingleton(config);
+
+        const scopeNode = getValueFromObjectLiteral(config, 'scope');
+        if (scopeNode) {
+          if (ts.isStringLiteral(scopeNode)) {
+            meta.scope = scopeNode.text;
+          }
+        }
+      }
+    }
+
+    return meta;
+  }
+
   public get propertyDependencies(): {
     property: string;
     type: ts.ClassDeclaration;

tests/compiler/compiler.compatibility.test.ts

@@ -4,7 +4,34 @@ test.only('TSDI compiler generates configuration for runtime components', async
   const files: { [name: string]: string } = {
     '/file.ts': `
       import { container } from '/decorators';
-      import { component, inject } from 'tsdi';
+      import { component, inject, initialize, destroy } from 'tsdi';
+
+      let initCalled = false;
+      let disposeCalled = false;
+
+      @component({scope: 'scope'})
+      export class ComponentWithScopeAndLifecycle {
+
+        @initialize
+        protected init(): void {
+          initCalled = true;
+          disposeCalled = true;
+        }
+
+        @destroy
+        protected dispose(): void {
+          disposeCalled = true;
+        }
+
+        public call(): void {
+          //
+        }
+
+      }
+
+      @component({singleton: false})
+      export class NonSingleton {
+      }
 
       @component
       export class Dependency {
@@ -21,10 +48,26 @@ test.only('TSDI compiler generates configuration for runtime components', async
       @container({ units: [] })
       export abstract class Container {
         public abstract component: Component;
+        public abstract dependency: Dependency;
+        public abstract scoped: ComponentWithScopeAndLifecycle;
+        public abstract nonSingleton: NonSingleton;
+
+        public getTSDI(): TSDI {
+          return this.tsdi;
+        }
       }
 
       export function test(expect, container) {
         expect(container.component).toBeInstanceOf(Component);
+
+        expect(container.component.dependency).toBe(container.dependency);
+
+        expect(() => container.scoped.call()).toThrow();
+        container.getTSDI().getScope('scope').enter();
+        container.scoped.call()
+        container.getTSDI().getScope('scope').leave();
+
+        expect(container.nonSingleton).not.toBe(container.nonSingleton);
       }
     `
   };