@tsed/di 6.81.0 → 6.84.1

package/lib/index.modern.js

@@ -1,4 +1,4 @@
-import { getClassOrSymbol, Store, isClass, classOf, nameOf, StoreSet, DecoratorTypes, decoratorTypeOf, UnsupportedDecoratorType, Metadata, isPromise, importPackage, isString, isFunction, isBoolean, useDecorators, isArrayOrArrayClass, getConstructorArgNames, proxyDelegation, setValue, getValue, deepMerge, deepClone, ancestorsOf, prototypeOf, catchError, isInheritedFrom, Env } from '@tsed/core';
+import { getClassOrSymbol, Store, isClass, classOf, nameOf, StoreSet, DecoratorTypes, decoratorTypeOf, UnsupportedDecoratorType, Metadata, isPromise, importPackage, useDecorators, isArrayOrArrayClass, isString, getConstructorArgNames, proxyDelegation, setValue, getValue, deepMerge, deepClone, ancestorsOf, prototypeOf, catchError, isFunction, isInheritedFrom, Env } from '@tsed/core';
 import { levels, Logger, $log } from '@tsed/logger';
 import { Path, Children } from '@tsed/schema';
 import { __decorate, __metadata } from 'tslib';
@@ -983,54 +983,47 @@ function Inject(symbol, onGet = bean => bean) {
   };
 }
 
-function mapOptions$1(args) {
-  const options = args.reduce((options, item) => {
-    if (isString(item)) {
-      options.packageName = item;
-    } else if (isFunction(item)) {
-      options.resolver = item;
-    } else if (isBoolean(item)) {
-      options.optional = item;
-    }
-
-    return options;
-  }, {
-    optional: false
-  });
-
-  if (!options.packageName && options.resolver) {
-    options.packageName = options.resolver.toString();
-  }
-
-  if (!options.resolver) {
-    options.resolver = () => import(options.packageName);
-  }
-
-  return options;
-}
+/**
+ * Lazy load a provider from his package and invoke only when the provider is used
+ *
+ * ```typescript
+ * import type {PlatformException} from "@tsed/platform-exceptions";
+ *
+ * @Injectable()
+ * export class MyService {
+ *   @LazyInject("PlatformException", () => import("@tsed/platform-exceptions"))
+ *   exceptions: Promise<PlatformException>;
+ * }
+ * ```
+ *
+ * @param key
+ * @param packageName
+ * @param resolver
+ * @param optional
+ * @returns {Function}
+ * @decorator
+ */
 
-function LazyInject(...args) {
-  const {
-    packageName,
-    resolver,
-    optional
-  } = mapOptions$1(args);
+function LazyInject(key, resolver, {
+  optional = false,
+  packageName = resolver.toString()
+} = {}) {
   return (target, propertyKey) => {
     let bean, token;
     injectProperty(target, propertyKey, {
       resolver(injector) {
         return async () => {
           if (!token) {
-            var _token;
-
-            token = await importPackage(packageName, resolver, optional);
-            token = ((_token = token) == null ? void 0 : _token.default) || token;
+            const exports = await importPackage(packageName, resolver, optional);
+            token = exports[key];
 
-            if (token && classOf(token) === Object && !optional) {
-              throw new Error(`Unable to lazy load the "${packageName}". Resolved token isn\'t a valid provider.`);
+            if (!token) {
+              if (!optional) {
+                throw new Error(`Unable to lazy load the "${key}". The token isn\'t a valid token provider.`);
+              }
             }
 
-            bean = await injector.lazyInvoke(token);
+            bean = token ? await injector.lazyInvoke(token) : {};
           }
 
           return bean;
@@ -1040,8 +1033,29 @@ function LazyInject(...args) {
     });
   };
 }
-function OptionalLazyInject(arg) {
-  return LazyInject(arg, true);
+/**
+ * Optionally Lazy load a provider from his package and invoke only when the provider is used
+ *
+ * ```typescript
+ * import type {PlatformException} from "@tsed/platform-exceptions";
+ *
+ * @Injectable()
+ * export class MyService {
+ *   @OptionalLazyInject("@tsed/platform-exceptions")
+ *   exceptions: Promise<PlatformException>;
+ * }
+ * ```
+ *
+ * @param key
+ * @param resolver
+ * @returns {Function}
+ * @decorator
+ */
+
+function OptionalLazyInject(key, resolver) {
+  return LazyInject(key, resolver, {
+    optional: true
+  });
 }
 
 /**