@tsed/di 6.83.0 → 6.86.0

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;
+            const exports = await importPackage(packageName, resolver, optional);
+            token = exports[key];
 
-            token = await importPackage(packageName, resolver, optional);
-            token = ((_token = token) == null ? void 0 : _token.default) || token;
-
-            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
+  });
 }
 
 /**
@@ -1396,9 +1410,18 @@ function Controller(options) {
   }, path && Path(path), Children(...children));
 }
 
+// istanbul ignore next
 const colorIfAllowed = colorFn => text => !process.env.NO_COLOR ? colorFn(text) : text;
 
 const red = colorIfAllowed(text => `\x1B[31m${text}\x1B[39m`);
+const yellow = colorIfAllowed(text => `\x1B[33m${text}\x1B[39m`);
+const green = colorIfAllowed(text => `\x1B[32m${text}\x1B[39m`);
+const colors = {
+  red,
+  yellow,
+  green
+};
+
 class InjectionError extends Error {
   constructor(token, origin) {
     super(isString(origin) ? origin : "");
@@ -1445,7 +1468,7 @@ function printDependencyInjectionError(token, options) {
   const args = getConstructorArgNames(token).map((arg, index) => {
     if (options.index === index) {
       erroredArg = arg;
-      arg = red(arg);
+      arg = colors.red(arg);
     }
 
     return `${arg}: ${nameOf(options.deps[index])}`;
@@ -1453,7 +1476,7 @@ function printDependencyInjectionError(token, options) {
   const signature = nameOf(token) + "->constructor(" + args + ")";
   const indexOf = signature.indexOf(erroredArg) - 5;
 
-  const drawline = indexOf => " ".repeat(indexOf) + red("^" + "‾".repeat(erroredArg.length - 1));
+  const drawline = indexOf => " ".repeat(indexOf) + colors.red("^" + "‾".repeat(erroredArg.length - 1));
 
   return "Unable to inject dependency. " + options.message + "\n\n" + signature + "\n" + (indexOf > -1 ? drawline(indexOf) : "");
 }
@@ -2419,5 +2442,5 @@ function getConfiguration(module, configuration = {}) {
   return config;
 }
 
-export { Configuration, Constant, Container, ContextLogger, Controller, DIConfiguration, DIContext, DITest, DI_PARAMS, DI_PARAM_OPTIONS, GlobalProviderRegistry, GlobalProviders, INJECTABLE_PROP, Inject, Injectable, InjectablePropertyType, InjectionError, InjectorService, Intercept, Interceptor, LazyInject, LocalsContainer, Module, OptionalLazyInject, Opts, OverrideProvider, Provider, ProviderScope, ProviderType, Scope, Service, UndefinedTokenError, UseOpts, Value, createContainer, getConfiguration, injectProperty, registerController, registerFactory, registerProvider, registerValue, setLoggerLevel };
+export { Configuration, Constant, Container, ContextLogger, Controller, DIConfiguration, DIContext, DITest, DI_PARAMS, DI_PARAM_OPTIONS, GlobalProviderRegistry, GlobalProviders, INJECTABLE_PROP, Inject, Injectable, InjectablePropertyType, InjectionError, InjectorService, Intercept, Interceptor, LazyInject, LocalsContainer, Module, OptionalLazyInject, Opts, OverrideProvider, Provider, ProviderScope, ProviderType, Scope, Service, UndefinedTokenError, UseOpts, Value, colors, createContainer, getConfiguration, injectProperty, registerController, registerFactory, registerProvider, registerValue, setLoggerLevel };
 //# sourceMappingURL=index.modern.js.map