@midwayjs/core 3.20.4 → 4.0.0-beta.1

package/dist/context/requestContainer.d.ts

@@ -1,14 +1,25 @@
-import { MidwayContainer } from './container';
-import { IMidwayContainer } from '../interface';
-export declare class MidwayRequestContainer extends MidwayContainer {
-    private readonly applicationContext;
-    constructor(ctx: any, applicationContext: IMidwayContainer);
-    init(): void;
-    get<T = any>(identifier: any, args?: any): T;
-    getAsync<T = any>(identifier: any, args?: any): Promise<T>;
-    ready(): Promise<void>;
-    getContext(): {
-        _MAIN_CTX_: boolean;
-    };
+import { ClassType, IMidwayGlobalContainer, IMidwayRequestContainer, ObjectIdentifier, ScopeEnum } from '../interface';
+import { ObjectDefinitionRegistry } from './definitionRegistry';
+export declare class MidwayRequestContainer implements IMidwayRequestContainer {
+    protected readonly ctx: any;
+    protected readonly applicationContext: IMidwayGlobalContainer;
+    parent: IMidwayGlobalContainer;
+    registry: ObjectDefinitionRegistry;
+    private attrMap;
+    constructor(ctx: any, applicationContext: IMidwayGlobalContainer);
+    get<T = any>(identifier: ClassType<T> | string, args?: any): T;
+    getAsync<T = any>(identifier: ClassType<T> | string, args?: any): Promise<T>;
+    getContext(): any;
+    hasDefinition(identifier: ObjectIdentifier): boolean;
+    getDefinition(identifier: ObjectIdentifier): import("../interface").IObjectDefinition;
+    registerObject(identifier: string, obj: any): void;
+    removeObject(identifier: ObjectIdentifier): void;
+    hasObject(identifier: ObjectIdentifier): boolean;
+    getObject<T>(identifier: ObjectIdentifier): T;
+    setAttr(key: string, value: any): void;
+    getAttr<T>(key: string): T;
+    getIdentifier(identifier: ClassType | string): string;
+    getInstanceScope(instance: any): ScopeEnum | undefined;
+    hasNamespace(namespace: string): boolean;
 }
 //# sourceMappingURL=requestContainer.d.ts.map

package/dist/context/requestContainer.js

@@ -1,16 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MidwayRequestContainer = void 0;
-const container_1 = require("./container");
-const decorator_1 = require("../decorator");
 const constants_1 = require("../constants");
-class MidwayRequestContainer extends container_1.MidwayContainer {
+const definitionRegistry_1 = require("./definitionRegistry");
+class MidwayRequestContainer {
     constructor(ctx, applicationContext) {
-        super(applicationContext);
+        this.ctx = ctx;
         this.applicationContext = applicationContext;
+        this.registry = new definitionRegistry_1.ObjectDefinitionRegistry();
+        this.attrMap = new Map();
+        this.parent = applicationContext;
         // update legacy relationship
         this.registry.setIdentifierRelation(this.applicationContext.registry.getIdentifierRelation());
-        this.ctx = ctx;
         // register ctx
         this.registerObject(constants_1.REQUEST_CTX_KEY, ctx);
         // register res
@@ -19,60 +20,54 @@ class MidwayRequestContainer extends container_1.MidwayContainer {
             // register contextLogger
             this.registerObject('logger', ctx.logger);
         }
-    }
-    init() {
-        // do nothing
+        ctx[constants_1.REQUEST_CTX_UNIQUE_KEY] = this;
     }
     get(identifier, args) {
-        if (typeof identifier !== 'string') {
-            identifier = this.getIdentifier(identifier);
-        }
-        if (this.registry.hasObject(identifier)) {
-            return this.registry.getObject(identifier);
-        }
-        const definition = this.applicationContext.registry.getDefinition(identifier);
-        if (definition) {
-            if (definition.isRequestScope() ||
-                definition.id === decorator_1.PIPELINE_IDENTIFIER) {
-                // create object from applicationContext definition for requestScope
-                return this.getManagedResolverFactory().create({
-                    definition,
-                    args,
-                });
-            }
-        }
-        if (this.parent) {
-            return this.parent.get(identifier, args);
-        }
+        return this.parent
+            .getManagedResolverFactory()
+            .create(identifier, args, this);
     }
     async getAsync(identifier, args) {
-        if (typeof identifier !== 'string') {
-            identifier = this.getIdentifier(identifier);
-        }
-        if (this.registry.hasObject(identifier)) {
-            return this.registry.getObject(identifier);
-        }
-        const definition = this.applicationContext.registry.getDefinition(identifier);
-        if (definition) {
-            if (definition.isRequestScope() ||
-                definition.id === decorator_1.PIPELINE_IDENTIFIER) {
-                // create object from applicationContext definition for requestScope
-                return this.getManagedResolverFactory().createAsync({
-                    definition,
-                    args,
-                });
-            }
-        }
-        if (this.parent) {
-            return this.parent.getAsync(identifier, args);
-        }
-    }
-    async ready() {
-        // ignore other things
+        return this.parent
+            .getManagedResolverFactory()
+            .createAsync(identifier, args, this);
     }
     getContext() {
         return this.ctx;
     }
+    hasDefinition(identifier) {
+        return this.parent.hasDefinition(identifier);
+    }
+    getDefinition(identifier) {
+        return this.parent.getDefinition(identifier);
+    }
+    registerObject(identifier, obj) {
+        this.registry.registerObject(identifier, obj);
+    }
+    removeObject(identifier) {
+        this.registry.removeObject(identifier);
+    }
+    hasObject(identifier) {
+        return this.registry.hasObject(identifier);
+    }
+    getObject(identifier) {
+        return this.registry.getObject(identifier);
+    }
+    setAttr(key, value) {
+        this.attrMap.set(key, value);
+    }
+    getAttr(key) {
+        return this.attrMap.get(key);
+    }
+    getIdentifier(identifier) {
+        return this.parent.getIdentifier(identifier);
+    }
+    getInstanceScope(instance) {
+        return this.parent.getInstanceScope(instance);
+    }
+    hasNamespace(namespace) {
+        return this.parent.hasNamespace(namespace);
+    }
 }
 exports.MidwayRequestContainer = MidwayRequestContainer;
 //# sourceMappingURL=requestContainer.js.map

package/dist/decorator/common/aspect.js

@@ -2,20 +2,20 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Aspect = void 0;
 const __1 = require("../");
-const objectDef_1 = require("./objectDef");
 const interface_1 = require("../../interface");
+const metadataManager_1 = require("../metadataManager");
 function Aspect(aspectTarget, match, priority) {
     return function (target) {
-        (0, __1.saveModule)(__1.ASPECT_KEY, target);
+        __1.DecoratorManager.saveModule(__1.ASPECT_KEY, target);
         const aspectTargets = [].concat(aspectTarget);
         for (const aspectTarget of aspectTargets) {
-            (0, __1.attachClassMetadata)(__1.ASPECT_KEY, {
+            metadataManager_1.MetadataManager.attachMetadata(__1.ASPECT_KEY, {
                 aspectTarget,
                 match,
                 priority,
             }, target);
         }
-        (0, objectDef_1.Scope)(interface_1.ScopeEnum.Singleton)(target);
+        (0, __1.Scope)(interface_1.ScopeEnum.Singleton)(target);
         (0, __1.Provide)()(target);
     };
 }

package/dist/decorator/common/autoload.js

@@ -5,7 +5,7 @@ const decoratorManager_1 = require("../decoratorManager");
 const provide_1 = require("./provide");
 function Autoload() {
     return function (target) {
-        (0, decoratorManager_1.savePreloadModule)(target);
+        decoratorManager_1.DecoratorManager.savePreStartModule(target);
         (0, provide_1.Provide)()(target);
     };
 }

package/dist/decorator/common/configuration.d.ts

@@ -1,26 +1,3 @@
-import { IFileDetector } from '../../interface';
-export interface IComponentInfo {
-    component: any;
-    enabledEnvironment?: string[];
-}
-export interface ResolveFilter {
-    pattern: string | RegExp;
-    filter: (module: any, filter: any, bindModule: any) => any;
-    ignoreRequire?: boolean;
-}
-export interface InjectionConfigurationOptions {
-    imports?: Array<string | IComponentInfo | {
-        Configuration: any;
-    }>;
-    importObjects?: Record<string, unknown>;
-    importConfigs?: Array<{
-        [environmentName: string]: Record<string, any>;
-    }> | Record<string, any>;
-    importConfigFilter?: (config: Record<string, any>) => Record<string, any>;
-    namespace?: string;
-    detector?: IFileDetector | false;
-    detectorOptions?: Record<string, any>;
-    conflictCheck?: boolean;
-}
+import { InjectionConfigurationOptions } from '../../interface';
 export declare function Configuration(options?: InjectionConfigurationOptions): ClassDecorator;
 //# sourceMappingURL=configuration.d.ts.map

package/dist/decorator/common/configuration.js

@@ -2,9 +2,14 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Configuration = void 0;
 const __1 = require("../");
+const metadataManager_1 = require("../metadataManager");
+const interface_1 = require("../../interface");
 function Configuration(options = {}) {
     return (target) => {
-        (0, __1.saveClassMetadata)(__1.CONFIGURATION_KEY, options, target);
+        options.namespace = options.namespace ?? __1.MAIN_MODULE_KEY;
+        metadataManager_1.MetadataManager.defineMetadata(__1.CONFIGURATION_KEY, options, target);
+        (0, __1.Scope)(interface_1.ScopeEnum.Singleton)(target);
+        (0, __1.Provide)()(target);
     };
 }
 exports.Configuration = Configuration;

package/dist/decorator/common/filter.js

@@ -1,29 +1,29 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Match = exports.Catch = void 0;
-const decoratorManager_1 = require("../decoratorManager");
 const constant_1 = require("../constant");
-const objectDef_1 = require("./objectDef");
 const provide_1 = require("./provide");
 const interface_1 = require("../../interface");
+const metadataManager_1 = require("../metadataManager");
+const scope_1 = require("./scope");
 function Catch(catchTarget, options = {}) {
     return function (target) {
         const catchTargets = catchTarget ? [].concat(catchTarget) : undefined;
-        (0, decoratorManager_1.saveClassMetadata)(constant_1.CATCH_KEY, {
+        metadataManager_1.MetadataManager.defineMetadata(constant_1.CATCH_KEY, {
             catchTargets,
             catchOptions: options,
         }, target);
-        (0, objectDef_1.Scope)(interface_1.ScopeEnum.Singleton)(target);
+        (0, scope_1.Scope)(interface_1.ScopeEnum.Singleton)(target);
         (0, provide_1.Provide)()(target);
     };
 }
 exports.Catch = Catch;
 function Match(matchPattern = true) {
     return function (target) {
-        (0, decoratorManager_1.saveClassMetadata)(constant_1.MATCH_KEY, {
+        metadataManager_1.MetadataManager.defineMetadata(constant_1.MATCH_KEY, {
             matchPattern,
         }, target);
-        (0, objectDef_1.Scope)(interface_1.ScopeEnum.Singleton)(target);
+        (0, scope_1.Scope)(interface_1.ScopeEnum.Singleton)(target);
         (0, provide_1.Provide)()(target);
     };
 }

package/dist/decorator/common/framework.d.ts

@@ -1,8 +1,51 @@
-import { FrameworkType } from '../../interface';
+/**
+ * Framework decorator, use to define the framework module
+ * @since 2.0.0
+ */
 export declare function Framework(): ClassDecorator;
+/**
+ * Plugin decorator, use to get egg plugin instance
+ * @since 2.0.0
+ */
 export declare function Plugin(identifier?: string): PropertyDecorator;
-export declare function Config(identifier?: string): PropertyDecorator;
-export declare function App(typeOrNamespace?: FrameworkType | string): PropertyDecorator;
+/**
+ * @deprecated Use @AllConfig() instead
+ * @since 2.0.0
+ */
+export declare function Config(): PropertyDecorator;
+/**
+ * Config decorator, use to get config
+ * @since 2.0.0
+ */
+export declare function Config(identifier: string): PropertyDecorator;
+/**
+ * Config decorator, use to get all config
+ * @since 4.0.0
+ */
+export declare function AllConfig(): PropertyDecorator;
+/**
+ * @deprecated Use @MainApp() instead
+ */
+export declare function App(): PropertyDecorator;
+/**
+ * App decorator, use to get application instance, default is main application
+ * If you want to get the application instance of other framework, you can use the namespace parameter to specify
+ * @since 2.0.0
+ */
+export declare function App(namespace: string): PropertyDecorator;
+/**
+ * Get the main application instance
+ * @since 4.0.0
+ */
+export declare function MainApp(): PropertyDecorator;
+/**
+ * Logger decorator, use to get logger instance
+ * @since 2.0.0
+ */
 export declare function Logger(identifier?: string): PropertyDecorator;
+/**
+ * ApplicationContext decorator, use to get global IoC container instance
+ * @since 3.0.0
+ */
 export declare function ApplicationContext(): PropertyDecorator;
 //# sourceMappingURL=framework.d.ts.map

package/dist/decorator/common/framework.js

@@ -1,42 +1,76 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ApplicationContext = exports.Logger = exports.App = exports.Config = exports.Plugin = exports.Framework = void 0;
+exports.ApplicationContext = exports.Logger = exports.MainApp = exports.App = exports.AllConfig = exports.Config = exports.Plugin = exports.Framework = void 0;
 const __1 = require("../");
 const interface_1 = require("../../interface");
+/**
+ * Framework decorator, use to define the framework module
+ * @since 2.0.0
+ */
 function Framework() {
     return (target) => {
-        (0, __1.saveModule)(__1.FRAMEWORK_KEY, target);
+        __1.DecoratorManager.saveModule(__1.FRAMEWORK_KEY, target);
         (0, __1.Scope)(interface_1.ScopeEnum.Singleton)(target);
         (0, __1.Provide)()(target);
     };
 }
 exports.Framework = Framework;
+/**
+ * Plugin decorator, use to get egg plugin instance
+ * @since 2.0.0
+ */
 function Plugin(identifier) {
-    return (0, __1.createCustomPropertyDecorator)(__1.PLUGIN_KEY, {
+    return __1.DecoratorManager.createCustomPropertyDecorator(__1.PLUGIN_KEY, {
         identifier,
     });
 }
 exports.Plugin = Plugin;
 function Config(identifier) {
-    return (0, __1.createCustomPropertyDecorator)(__1.CONFIG_KEY, {
+    return __1.DecoratorManager.createCustomPropertyDecorator(__1.CONFIG_KEY, {
         identifier,
     });
 }
 exports.Config = Config;
-function App(typeOrNamespace) {
-    return (0, __1.createCustomPropertyDecorator)(__1.APPLICATION_KEY, {
-        type: typeOrNamespace,
+/**
+ * Config decorator, use to get all config
+ * @since 4.0.0
+ */
+function AllConfig() {
+    return __1.DecoratorManager.createCustomPropertyDecorator(__1.CONFIG_KEY, {
+        identifier: __1.ALL_VALUE_KEY,
+    });
+}
+exports.AllConfig = AllConfig;
+function App(namespace) {
+    return __1.DecoratorManager.createCustomPropertyDecorator(__1.APPLICATION_KEY, {
+        type: namespace,
     });
 }
 exports.App = App;
+/**
+ * Get the main application instance
+ * @since 4.0.0
+ */
+function MainApp() {
+    return __1.DecoratorManager.createCustomPropertyDecorator(__1.MAIN_APPLICATION_KEY, {});
+}
+exports.MainApp = MainApp;
+/**
+ * Logger decorator, use to get logger instance
+ * @since 2.0.0
+ */
 function Logger(identifier) {
-    return (0, __1.createCustomPropertyDecorator)(__1.LOGGER_KEY, {
+    return __1.DecoratorManager.createCustomPropertyDecorator(__1.LOGGER_KEY, {
         identifier,
     });
 }
 exports.Logger = Logger;
+/**
+ * ApplicationContext decorator, use to get global IoC container instance
+ * @since 3.0.0
+ */
 function ApplicationContext() {
-    return (0, __1.createCustomPropertyDecorator)(__1.APPLICATION_CONTEXT_KEY, {});
+    return __1.DecoratorManager.createCustomPropertyDecorator(__1.APPLICATION_CONTEXT_KEY, {});
 }
 exports.ApplicationContext = ApplicationContext;
 //# sourceMappingURL=framework.js.map

package/dist/decorator/common/guard.js

@@ -1,29 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Guard = exports.UseGuard = void 0;
-const decoratorManager_1 = require("../decoratorManager");
 const interface_1 = require("../../interface");
 const constant_1 = require("../constant");
 const provide_1 = require("./provide");
-const objectDef_1 = require("./objectDef");
+const metadataManager_1 = require("../metadataManager");
+const scope_1 = require("./scope");
 function UseGuard(guardOrArr) {
     return (target, propertyKey, descriptor) => {
         if (!Array.isArray(guardOrArr)) {
             guardOrArr = [guardOrArr];
         }
-        if (propertyKey) {
-            (0, decoratorManager_1.savePropertyMetadata)(constant_1.GUARD_KEY, guardOrArr, target, propertyKey);
-        }
-        else {
-            (0, decoratorManager_1.saveClassMetadata)(constant_1.GUARD_KEY, guardOrArr, target);
-        }
+        metadataManager_1.MetadataManager.defineMetadata(constant_1.GUARD_KEY, guardOrArr, target, propertyKey);
     };
 }
 exports.UseGuard = UseGuard;
 function Guard() {
     return target => {
         (0, provide_1.Provide)()(target);
-        (0, objectDef_1.Scope)(interface_1.ScopeEnum.Singleton)(target);
+        (0, scope_1.Scope)(interface_1.ScopeEnum.Singleton)(target);
     };
 }
 exports.Guard = Guard;

package/dist/decorator/common/inject.d.ts

@@ -1,4 +1,6 @@
-import { IServiceFactory, ObjectIdentifier } from '../../interface';
-export declare function Inject(identifier?: ObjectIdentifier): (target: any, targetKey: string) => void;
+import { IServiceFactory, ObjectIdentifier, ClassType } from '../../interface';
+export declare function saveInjectMetadata(identifier: any, target: any, targetKey: any, isLazyInject?: boolean, parameterIndex?: number): void;
+export declare function Inject(identifier?: ObjectIdentifier): PropertyDecorator & ParameterDecorator;
+export declare function LazyInject(identifier?: ObjectIdentifier | (() => ObjectIdentifier | ClassType)): PropertyDecorator & ParameterDecorator;
 export declare function InjectClient(serviceFactoryClz: new (...args: any[]) => IServiceFactory<unknown>, clientName?: string): PropertyDecorator;
 //# sourceMappingURL=inject.d.ts.map

package/dist/decorator/common/inject.js

@@ -1,16 +1,99 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.InjectClient = exports.Inject = void 0;
+exports.InjectClient = exports.LazyInject = exports.Inject = exports.saveInjectMetadata = void 0;
 const decoratorManager_1 = require("../decoratorManager");
+const interface_1 = require("../../interface");
 const constant_1 = require("../constant");
+const types_1 = require("../../util/types");
+const metadataManager_1 = require("../metadataManager");
+const util_1 = require("../../util");
+function getConstructParamNames(target) {
+    let paramNames = metadataManager_1.MetadataManager.getOwnMetadata('constructorParamNames', target);
+    if (!paramNames) {
+        // cache constructor param names
+        paramNames = (0, util_1.getParamNames)(target);
+        metadataManager_1.MetadataManager.defineMetadata('constructorParamNames', paramNames, target);
+    }
+    return paramNames;
+}
+function saveInjectMetadata(identifier, target, targetKey, isLazyInject = false, parameterIndex) {
+    // 1、use identifier by user
+    // let identifier = opts.identifier;
+    let injectMode = interface_1.InjectModeEnum.Identifier;
+    let id = identifier;
+    const isConstructor = parameterIndex !== undefined;
+    // 2、use identifier by class uuid
+    if (isConstructor) {
+        const paramNames = getConstructParamNames(target);
+        if (!id) {
+            const argsTypes = metadataManager_1.MetadataManager.getMethodParamTypes(target, targetKey);
+            const type = metadataManager_1.MetadataManager.transformTypeFromTSDesign(argsTypes[parameterIndex]);
+            if (!type.isBaseType &&
+                (0, types_1.isClass)(type.originDesign) &&
+                decoratorManager_1.DecoratorManager.isProvide(type.originDesign)) {
+                id = decoratorManager_1.DecoratorManager.getProviderUUId(type.originDesign);
+                injectMode = interface_1.InjectModeEnum.Class;
+            }
+            if (!id) {
+                // 3、use identifier by property name
+                id = paramNames[parameterIndex];
+                injectMode = interface_1.InjectModeEnum.SelfName;
+            }
+        }
+        metadataManager_1.MetadataManager.attachMetadata(constant_1.CONSTRUCTOR_INJECT_KEY, {
+            targetKey,
+            id,
+            name: paramNames[parameterIndex],
+            injectMode,
+            isLazyInject,
+            parameterIndex,
+        }, target, 'default');
+    }
+    else {
+        if (!id) {
+            const type = metadataManager_1.MetadataManager.transformTypeFromTSDesign(metadataManager_1.MetadataManager.getPropertyType(target, targetKey));
+            if (!type.isBaseType &&
+                (0, types_1.isClass)(type.originDesign) &&
+                decoratorManager_1.DecoratorManager.isProvide(type.originDesign)) {
+                id = decoratorManager_1.DecoratorManager.getProviderUUId(type.originDesign);
+                injectMode = interface_1.InjectModeEnum.Class;
+            }
+            if (!id) {
+                // 3、use identifier by property name
+                id = targetKey;
+                injectMode = interface_1.InjectModeEnum.SelfName;
+            }
+        }
+        metadataManager_1.MetadataManager.defineMetadata(constant_1.PROPERTY_INJECT_KEY, {
+            targetKey,
+            id,
+            name: targetKey,
+            isLazyInject,
+            injectMode,
+        }, target, targetKey);
+    }
+}
+exports.saveInjectMetadata = saveInjectMetadata;
 function Inject(identifier) {
-    return function (target, targetKey) {
-        (0, decoratorManager_1.savePropertyInject)({ target, targetKey, identifier });
+    return function (target, targetKey, parameterIndex) {
+        return saveInjectMetadata(identifier, target, targetKey, false, parameterIndex);
     };
 }
 exports.Inject = Inject;
+function LazyInject(identifier) {
+    let id = identifier;
+    if (id && typeof id !== 'function') {
+        id = (() => {
+            return identifier;
+        });
+    }
+    return function (target, targetKey, parameterIndex) {
+        return saveInjectMetadata(id, target, targetKey, true, parameterIndex);
+    };
+}
+exports.LazyInject = LazyInject;
 function InjectClient(serviceFactoryClz, clientName) {
-    return (0, decoratorManager_1.createCustomPropertyDecorator)(constant_1.FACTORY_SERVICE_CLIENT_KEY, {
+    return decoratorManager_1.DecoratorManager.createCustomPropertyDecorator(constant_1.FACTORY_SERVICE_CLIENT_KEY, {
         serviceFactoryClz,
         clientName,
     });

package/dist/decorator/common/mock.js

@@ -5,7 +5,7 @@ const __1 = require("../");
 const interface_1 = require("../../interface");
 function Mock() {
     return (target) => {
-        (0, __1.saveModule)(__1.MOCK_KEY, target);
+        __1.DecoratorManager.saveModule(__1.MOCK_KEY, target);
         (0, __1.Scope)(interface_1.ScopeEnum.Singleton)(target);
         (0, __1.Provide)()(target);
     };

package/dist/decorator/common/objectDef.d.ts

@@ -1,8 +1,3 @@
-import { ScopeEnum } from '../../interface';
 export declare function Init(): MethodDecorator;
 export declare function Destroy(): MethodDecorator;
-export declare function Scope(scope: ScopeEnum, scopeOptions?: {
-    allowDowngrade?: boolean;
-}): ClassDecorator;
-export declare function Singleton(): ClassDecorator;
 //# sourceMappingURL=objectDef.d.ts.map

package/dist/decorator/common/objectDef.js

@@ -1,34 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Singleton = exports.Scope = exports.Destroy = exports.Init = void 0;
-const decoratorManager_1 = require("../decoratorManager");
-const provide_1 = require("./provide");
-const interface_1 = require("../../interface");
+exports.Destroy = exports.Init = void 0;
+const metadataManager_1 = require("../metadataManager");
+const constant_1 = require("../constant");
 function Init() {
     return function (target, propertyKey) {
-        (0, decoratorManager_1.saveObjectDefinition)(target, { initMethod: propertyKey });
+        metadataManager_1.MetadataManager.attachMetadata(constant_1.OBJECT_DEFINITION_KEY, {
+            initMethod: propertyKey,
+        }, target, propertyKey);
     };
 }
 exports.Init = Init;
 function Destroy() {
     return function (target, propertyKey) {
-        (0, decoratorManager_1.saveObjectDefinition)(target, {
+        metadataManager_1.MetadataManager.attachMetadata(constant_1.OBJECT_DEFINITION_KEY, {
             destroyMethod: propertyKey,
-        });
+        }, target, propertyKey);
     };
 }
 exports.Destroy = Destroy;
-function Scope(scope, scopeOptions) {
-    return function (target) {
-        (0, decoratorManager_1.saveObjectDefinition)(target, { scope, ...scopeOptions });
-    };
-}
-exports.Scope = Scope;
-function Singleton() {
-    return function (target) {
-        Scope(interface_1.ScopeEnum.Singleton)(target);
-        (0, provide_1.Provide)()(target);
-    };
-}
-exports.Singleton = Singleton;
 //# sourceMappingURL=objectDef.js.map

package/dist/decorator/common/provide.d.ts

@@ -1,3 +1,3 @@
 import { ObjectIdentifier } from '../../interface';
-export declare function Provide(identifier?: ObjectIdentifier): (target: any) => any;
+export declare function Provide(identifier?: ObjectIdentifier): (target: any) => void;
 //# sourceMappingURL=provide.d.ts.map

package/dist/decorator/common/provide.js

@@ -4,7 +4,7 @@ exports.Provide = void 0;
 const decoratorManager_1 = require("../decoratorManager");
 function Provide(identifier) {
     return function (target) {
-        return (0, decoratorManager_1.saveProviderId)(identifier, target);
+        decoratorManager_1.DecoratorManager.saveProviderId(identifier, target);
     };
 }
 exports.Provide = Provide;

package/dist/decorator/common/scope.d.ts

@@ -0,0 +1,6 @@
+import { ScopeEnum } from '../../interface';
+export declare function Scope(scope: ScopeEnum, scopeOptions?: {
+    allowDowngrade?: boolean;
+}): ClassDecorator;
+export declare function Singleton(): ClassDecorator;
+//# sourceMappingURL=scope.d.ts.map