@tsed/di 6.81.0 → 6.84.1

package/lib/decorators/lazyInject.d.ts

@@ -6,31 +6,22 @@
  *
  * @Injectable()
  * export class MyService {
- *   @LazyInject("@tsed/platform-exceptions") // work if the module have a class exported with "default"
- *   exceptions: Promise<PlatformException>;
- * }
- *
- * @Injectable()
- * export class MyService {
- *   @LazyInject(() => import("@tsed/platform-exceptions")) // use this notation is you use webpack
- *   exceptions: Promise<PlatformException>;
- * }
- *
- * @Injectable()
- * export class MyService {
- *   @LazyInject(async () => (await import("@tsed/platform-exceptions")).PlatformException)
+ *   @LazyInject("PlatformException", () => import("@tsed/platform-exceptions"))
  *   exceptions: Promise<PlatformException>;
  * }
  * ```
  *
+ * @param key
  * @param packageName
  * @param resolver
  * @param optional
  * @returns {Function}
  * @decorator
  */
-export declare function LazyInject(resolver: () => any, optional?: boolean): PropertyDecorator;
-export declare function LazyInject(packageName: string, optional?: boolean): PropertyDecorator;
+export declare function LazyInject(key: string, resolver: () => any, { optional, packageName }?: {
+    optional?: boolean;
+    packageName?: string;
+}): PropertyDecorator;
 /**
  * Optionally Lazy load a provider from his package and invoke only when the provider is used
  *
@@ -44,10 +35,9 @@ export declare function LazyInject(packageName: string, optional?: boolean): Pro
  * }
  * ```
  *
- * @param packageName
+ * @param key
  * @param resolver
  * @returns {Function}
  * @decorator
  */
-export declare function OptionalLazyInject(resolver: () => any): PropertyDecorator;
-export declare function OptionalLazyInject(packageName: string): PropertyDecorator;
+export declare function OptionalLazyInject(key: string, resolver: () => any): PropertyDecorator;

package/lib/index.js

@@ -3,26 +3,6 @@ var logger = require('@tsed/logger');
 var schema = require('@tsed/schema');
 var tslib = require('tslib');
 
-function _interopNamespace(e) {
-  if (e && e.__esModule) return e;
-  var n = Object.create(null);
-  if (e) {
-    Object.keys(e).forEach(function (k) {
-      if (k !== 'default') {
-        var d = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n, k, d.get ? d : {
-          enumerable: true,
-          get: function () {
-            return e[k];
-          }
-        });
-      }
-    });
-  }
-  n['default'] = e;
-  return n;
-}
-
 const INJECTABLE_PROP = "DI:INJECTABLE_PROP";
 const DI_PARAMS = "DI:PARAMS";
 const DI_PARAM_OPTIONS = "DI:PARAM:OPTIONS";
@@ -1003,54 +983,47 @@ function Inject(symbol, onGet = bean => bean) {
   };
 }
 
-function mapOptions$1(args) {
-  const options = args.reduce((options, item) => {
-    if (core.isString(item)) {
-      options.packageName = item;
-    } else if (core.isFunction(item)) {
-      options.resolver = item;
-    } else if (core.isBoolean(item)) {
-      options.optional = item;
-    }
-
-    return options;
-  }, {
-    optional: false
-  });
-
-  if (!options.packageName && options.resolver) {
-    options.packageName = options.resolver.toString();
-  }
-
-  if (!options.resolver) {
-    options.resolver = () => Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require(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 core.importPackage(packageName, resolver, optional);
-            token = ((_token = token) == null ? void 0 : _token.default) || token;
+            const exports = await core.importPackage(packageName, resolver, optional);
+            token = exports[key];
 
-            if (token && core.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;
@@ -1060,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
+  });
 }
 
 /**