web-dc-api 0.0.58 → 0.0.60

package/dist/cjs/node_modules/tsyringe/dist/esm5/dependency-container.js

@@ -0,0 +1,444 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib_es6 = require('../../../tslib/tslib.es6.js');
+var classProvider = require('./providers/class-provider.js');
+var factoryProvider = require('./providers/factory-provider.js');
+var injectionToken = require('./providers/injection-token.js');
+var tokenProvider = require('./providers/token-provider.js');
+var valueProvider = require('./providers/value-provider.js');
+var provider = require('./providers/provider.js');
+var registry = require('./registry.js');
+var lifecycle = require('./types/lifecycle.js');
+var resolutionContext = require('./resolution-context.js');
+var errorHelpers = require('./error-helpers.js');
+var lazyHelpers = require('./lazy-helpers.js');
+var disposable = require('./types/disposable.js');
+var interceptors = require('./interceptors.js');
+
+var typeInfo = new Map();
+var InternalDependencyContainer = function () {
+  function InternalDependencyContainer(parent) {
+    this.parent = parent;
+    this._registry = new registry.default();
+    this.interceptors = new interceptors.default();
+    this.disposed = false;
+    this.disposables = new Set();
+  }
+  InternalDependencyContainer.prototype.register = function (token, providerOrConstructor, options) {
+    if (options === void 0) {
+      options = {
+        lifecycle: lifecycle.default.Transient
+      };
+    }
+    this.ensureNotDisposed();
+    var provider$1;
+    if (!provider.isProvider(providerOrConstructor)) {
+      provider$1 = {
+        useClass: providerOrConstructor
+      };
+    } else {
+      provider$1 = providerOrConstructor;
+    }
+    if (tokenProvider.isTokenProvider(provider$1)) {
+      var path = [token];
+      var tokenProvider$1 = provider$1;
+      while (tokenProvider$1 != null) {
+        var currentToken = tokenProvider$1.useToken;
+        if (path.includes(currentToken)) {
+          throw new Error("Token registration cycle detected! " + tslib_es6.__spread(path, [currentToken]).join(" -> "));
+        }
+        path.push(currentToken);
+        var registration = this._registry.get(currentToken);
+        if (registration && tokenProvider.isTokenProvider(registration.provider)) {
+          tokenProvider$1 = registration.provider;
+        } else {
+          tokenProvider$1 = null;
+        }
+      }
+    }
+    if (options.lifecycle === lifecycle.default.Singleton || options.lifecycle == lifecycle.default.ContainerScoped || options.lifecycle == lifecycle.default.ResolutionScoped) {
+      if (valueProvider.isValueProvider(provider$1) || factoryProvider.isFactoryProvider(provider$1)) {
+        throw new Error("Cannot use lifecycle \"" + lifecycle.default[options.lifecycle] + "\" with ValueProviders or FactoryProviders");
+      }
+    }
+    this._registry.set(token, {
+      provider: provider$1,
+      options: options
+    });
+    return this;
+  };
+  InternalDependencyContainer.prototype.registerType = function (from, to) {
+    this.ensureNotDisposed();
+    if (injectionToken.isNormalToken(to)) {
+      return this.register(from, {
+        useToken: to
+      });
+    }
+    return this.register(from, {
+      useClass: to
+    });
+  };
+  InternalDependencyContainer.prototype.registerInstance = function (token, instance) {
+    this.ensureNotDisposed();
+    return this.register(token, {
+      useValue: instance
+    });
+  };
+  InternalDependencyContainer.prototype.registerSingleton = function (from, to) {
+    this.ensureNotDisposed();
+    if (injectionToken.isNormalToken(from)) {
+      if (injectionToken.isNormalToken(to)) {
+        return this.register(from, {
+          useToken: to
+        }, {
+          lifecycle: lifecycle.default.Singleton
+        });
+      } else if (to) {
+        return this.register(from, {
+          useClass: to
+        }, {
+          lifecycle: lifecycle.default.Singleton
+        });
+      }
+      throw new Error('Cannot register a type name as a singleton without a "to" token');
+    }
+    var useClass = from;
+    if (to && !injectionToken.isNormalToken(to)) {
+      useClass = to;
+    }
+    return this.register(from, {
+      useClass: useClass
+    }, {
+      lifecycle: lifecycle.default.Singleton
+    });
+  };
+  InternalDependencyContainer.prototype.resolve = function (token, context, isOptional) {
+    if (context === void 0) {
+      context = new resolutionContext.default();
+    }
+    if (isOptional === void 0) {
+      isOptional = false;
+    }
+    this.ensureNotDisposed();
+    var registration = this.getRegistration(token);
+    if (!registration && injectionToken.isNormalToken(token)) {
+      if (isOptional) {
+        return undefined;
+      }
+      throw new Error("Attempted to resolve unregistered dependency token: \"" + token.toString() + "\"");
+    }
+    this.executePreResolutionInterceptor(token, "Single");
+    if (registration) {
+      var result = this.resolveRegistration(registration, context);
+      this.executePostResolutionInterceptor(token, result, "Single");
+      return result;
+    }
+    if (injectionToken.isConstructorToken(token)) {
+      var result = this.construct(token, context);
+      this.executePostResolutionInterceptor(token, result, "Single");
+      return result;
+    }
+    throw new Error("Attempted to construct an undefined constructor. Could mean a circular dependency problem. Try using `delay` function.");
+  };
+  InternalDependencyContainer.prototype.executePreResolutionInterceptor = function (token, resolutionType) {
+    var e_1, _a;
+    if (this.interceptors.preResolution.has(token)) {
+      var remainingInterceptors = [];
+      try {
+        for (var _b = tslib_es6.__values(this.interceptors.preResolution.getAll(token)), _c = _b.next(); !_c.done; _c = _b.next()) {
+          var interceptor = _c.value;
+          if (interceptor.options.frequency != "Once") {
+            remainingInterceptors.push(interceptor);
+          }
+          interceptor.callback(token, resolutionType);
+        }
+      } catch (e_1_1) {
+        e_1 = {
+          error: e_1_1
+        };
+      } finally {
+        try {
+          if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        } finally {
+          if (e_1) throw e_1.error;
+        }
+      }
+      this.interceptors.preResolution.setAll(token, remainingInterceptors);
+    }
+  };
+  InternalDependencyContainer.prototype.executePostResolutionInterceptor = function (token, result, resolutionType) {
+    var e_2, _a;
+    if (this.interceptors.postResolution.has(token)) {
+      var remainingInterceptors = [];
+      try {
+        for (var _b = tslib_es6.__values(this.interceptors.postResolution.getAll(token)), _c = _b.next(); !_c.done; _c = _b.next()) {
+          var interceptor = _c.value;
+          if (interceptor.options.frequency != "Once") {
+            remainingInterceptors.push(interceptor);
+          }
+          interceptor.callback(token, result, resolutionType);
+        }
+      } catch (e_2_1) {
+        e_2 = {
+          error: e_2_1
+        };
+      } finally {
+        try {
+          if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        } finally {
+          if (e_2) throw e_2.error;
+        }
+      }
+      this.interceptors.postResolution.setAll(token, remainingInterceptors);
+    }
+  };
+  InternalDependencyContainer.prototype.resolveRegistration = function (registration, context) {
+    this.ensureNotDisposed();
+    if (registration.options.lifecycle === lifecycle.default.ResolutionScoped && context.scopedResolutions.has(registration)) {
+      return context.scopedResolutions.get(registration);
+    }
+    var isSingleton = registration.options.lifecycle === lifecycle.default.Singleton;
+    var isContainerScoped = registration.options.lifecycle === lifecycle.default.ContainerScoped;
+    var returnInstance = isSingleton || isContainerScoped;
+    var resolved;
+    if (valueProvider.isValueProvider(registration.provider)) {
+      resolved = registration.provider.useValue;
+    } else if (tokenProvider.isTokenProvider(registration.provider)) {
+      resolved = returnInstance ? registration.instance || (registration.instance = this.resolve(registration.provider.useToken, context)) : this.resolve(registration.provider.useToken, context);
+    } else if (classProvider.isClassProvider(registration.provider)) {
+      resolved = returnInstance ? registration.instance || (registration.instance = this.construct(registration.provider.useClass, context)) : this.construct(registration.provider.useClass, context);
+    } else if (factoryProvider.isFactoryProvider(registration.provider)) {
+      resolved = registration.provider.useFactory(this);
+    } else {
+      resolved = this.construct(registration.provider, context);
+    }
+    if (registration.options.lifecycle === lifecycle.default.ResolutionScoped) {
+      context.scopedResolutions.set(registration, resolved);
+    }
+    return resolved;
+  };
+  InternalDependencyContainer.prototype.resolveAll = function (token, context, isOptional) {
+    var _this = this;
+    if (context === void 0) {
+      context = new resolutionContext.default();
+    }
+    if (isOptional === void 0) {
+      isOptional = false;
+    }
+    this.ensureNotDisposed();
+    var registrations = this.getAllRegistrations(token);
+    if (!registrations && injectionToken.isNormalToken(token)) {
+      if (isOptional) {
+        return [];
+      }
+      throw new Error("Attempted to resolve unregistered dependency token: \"" + token.toString() + "\"");
+    }
+    this.executePreResolutionInterceptor(token, "All");
+    if (registrations) {
+      var result_1 = registrations.map(function (item) {
+        return _this.resolveRegistration(item, context);
+      });
+      this.executePostResolutionInterceptor(token, result_1, "All");
+      return result_1;
+    }
+    var result = [this.construct(token, context)];
+    this.executePostResolutionInterceptor(token, result, "All");
+    return result;
+  };
+  InternalDependencyContainer.prototype.isRegistered = function (token, recursive) {
+    if (recursive === void 0) {
+      recursive = false;
+    }
+    this.ensureNotDisposed();
+    return this._registry.has(token) || recursive && (this.parent || false) && this.parent.isRegistered(token, true);
+  };
+  InternalDependencyContainer.prototype.reset = function () {
+    this.ensureNotDisposed();
+    this._registry.clear();
+    this.interceptors.preResolution.clear();
+    this.interceptors.postResolution.clear();
+  };
+  InternalDependencyContainer.prototype.clearInstances = function () {
+    var e_3, _a;
+    this.ensureNotDisposed();
+    try {
+      for (var _b = tslib_es6.__values(this._registry.entries()), _c = _b.next(); !_c.done; _c = _b.next()) {
+        var _d = tslib_es6.__read(_c.value, 2),
+          token = _d[0],
+          registrations = _d[1];
+        this._registry.setAll(token, registrations.filter(function (registration) {
+          return !valueProvider.isValueProvider(registration.provider);
+        }).map(function (registration) {
+          registration.instance = undefined;
+          return registration;
+        }));
+      }
+    } catch (e_3_1) {
+      e_3 = {
+        error: e_3_1
+      };
+    } finally {
+      try {
+        if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+      } finally {
+        if (e_3) throw e_3.error;
+      }
+    }
+  };
+  InternalDependencyContainer.prototype.createChildContainer = function () {
+    var e_4, _a;
+    this.ensureNotDisposed();
+    var childContainer = new InternalDependencyContainer(this);
+    try {
+      for (var _b = tslib_es6.__values(this._registry.entries()), _c = _b.next(); !_c.done; _c = _b.next()) {
+        var _d = tslib_es6.__read(_c.value, 2),
+          token = _d[0],
+          registrations = _d[1];
+        if (registrations.some(function (_a) {
+          var options = _a.options;
+          return options.lifecycle === lifecycle.default.ContainerScoped;
+        })) {
+          childContainer._registry.setAll(token, registrations.map(function (registration) {
+            if (registration.options.lifecycle === lifecycle.default.ContainerScoped) {
+              return {
+                provider: registration.provider,
+                options: registration.options
+              };
+            }
+            return registration;
+          }));
+        }
+      }
+    } catch (e_4_1) {
+      e_4 = {
+        error: e_4_1
+      };
+    } finally {
+      try {
+        if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+      } finally {
+        if (e_4) throw e_4.error;
+      }
+    }
+    return childContainer;
+  };
+  InternalDependencyContainer.prototype.beforeResolution = function (token, callback, options) {
+    if (options === void 0) {
+      options = {
+        frequency: "Always"
+      };
+    }
+    this.interceptors.preResolution.set(token, {
+      callback: callback,
+      options: options
+    });
+  };
+  InternalDependencyContainer.prototype.afterResolution = function (token, callback, options) {
+    if (options === void 0) {
+      options = {
+        frequency: "Always"
+      };
+    }
+    this.interceptors.postResolution.set(token, {
+      callback: callback,
+      options: options
+    });
+  };
+  InternalDependencyContainer.prototype.dispose = function () {
+    return tslib_es6.__awaiter(this, void 0, void 0, function () {
+      var promises;
+      return tslib_es6.__generator(this, function (_a) {
+        switch (_a.label) {
+          case 0:
+            this.disposed = true;
+            promises = [];
+            this.disposables.forEach(function (disposable) {
+              var maybePromise = disposable.dispose();
+              if (maybePromise) {
+                promises.push(maybePromise);
+              }
+            });
+            return [4, Promise.all(promises)];
+          case 1:
+            _a.sent();
+            return [2];
+        }
+      });
+    });
+  };
+  InternalDependencyContainer.prototype.getRegistration = function (token) {
+    if (this.isRegistered(token)) {
+      return this._registry.get(token);
+    }
+    if (this.parent) {
+      return this.parent.getRegistration(token);
+    }
+    return null;
+  };
+  InternalDependencyContainer.prototype.getAllRegistrations = function (token) {
+    if (this.isRegistered(token)) {
+      return this._registry.getAll(token);
+    }
+    if (this.parent) {
+      return this.parent.getAllRegistrations(token);
+    }
+    return null;
+  };
+  InternalDependencyContainer.prototype.construct = function (ctor, context) {
+    var _this = this;
+    if (ctor instanceof lazyHelpers.DelayedConstructor) {
+      return ctor.createProxy(function (target) {
+        return _this.resolve(target, context);
+      });
+    }
+    var instance = function () {
+      var paramInfo = typeInfo.get(ctor);
+      if (!paramInfo || paramInfo.length === 0) {
+        if (ctor.length === 0) {
+          return new ctor();
+        } else {
+          throw new Error("TypeInfo not known for \"" + ctor.name + "\"");
+        }
+      }
+      var params = paramInfo.map(_this.resolveParams(context, ctor));
+      return new (ctor.bind.apply(ctor, tslib_es6.__spread([void 0], params)))();
+    }();
+    if (disposable.isDisposable(instance)) {
+      this.disposables.add(instance);
+    }
+    return instance;
+  };
+  InternalDependencyContainer.prototype.resolveParams = function (context, ctor) {
+    var _this = this;
+    return function (param, idx) {
+      var _a, _b, _c;
+      try {
+        if (injectionToken.isTokenDescriptor(param)) {
+          if (injectionToken.isTransformDescriptor(param)) {
+            return param.multiple ? (_a = _this.resolve(param.transform)).transform.apply(_a, tslib_es6.__spread([_this.resolveAll(param.token, new resolutionContext.default(), param.isOptional)], param.transformArgs)) : (_b = _this.resolve(param.transform)).transform.apply(_b, tslib_es6.__spread([_this.resolve(param.token, context, param.isOptional)], param.transformArgs));
+          } else {
+            return param.multiple ? _this.resolveAll(param.token, new resolutionContext.default(), param.isOptional) : _this.resolve(param.token, context, param.isOptional);
+          }
+        } else if (injectionToken.isTransformDescriptor(param)) {
+          return (_c = _this.resolve(param.transform, context)).transform.apply(_c, tslib_es6.__spread([_this.resolve(param.token, context)], param.transformArgs));
+        }
+        return _this.resolve(param, context);
+      } catch (e) {
+        throw new Error(errorHelpers.formatErrorCtor(ctor, idx, e));
+      }
+    };
+  };
+  InternalDependencyContainer.prototype.ensureNotDisposed = function () {
+    if (this.disposed) {
+      throw new Error("This container has been disposed, you cannot interact with a disposed container");
+    }
+  };
+  return InternalDependencyContainer;
+}();
+var instance = new InternalDependencyContainer();
+
+exports.default = instance;
+exports.instance = instance;
+exports.typeInfo = typeInfo;

package/dist/cjs/node_modules/tsyringe/dist/esm5/error-helpers.js

@@ -0,0 +1,28 @@
+'use strict';
+
+var tslib_es6 = require('../../../tslib/tslib.es6.js');
+
+function formatDependency(params, idx) {
+  if (params === null) {
+    return "at position #" + idx;
+  }
+  var argName = params.split(",")[idx].trim();
+  return "\"" + argName + "\" at position #" + idx;
+}
+function composeErrorMessage(msg, e, indent) {
+  if (indent === void 0) {
+    indent = "    ";
+  }
+  return tslib_es6.__spread([msg], e.message.split("\n").map(function (l) {
+    return indent + l;
+  })).join("\n");
+}
+function formatErrorCtor(ctor, paramIdx, error) {
+  var _a = tslib_es6.__read(ctor.toString().match(/constructor\(([\w, ]+)\)/) || [], 2),
+    _b = _a[1],
+    params = _b === void 0 ? null : _b;
+  var dep = formatDependency(params, paramIdx);
+  return composeErrorMessage("Cannot inject the dependency " + dep + " of \"" + ctor.name + "\" constructor. Reason:", error);
+}
+
+exports.formatErrorCtor = formatErrorCtor;

package/dist/cjs/node_modules/tsyringe/dist/esm5/index.js

@@ -0,0 +1,13 @@
+'use strict';
+
+var lifecycle = require('./types/lifecycle.js');
+require('../../../tslib/tslib.es6.js');
+var dependencyContainer = require('./dependency-container.js');
+require('./lazy-helpers.js');
+
+if (typeof Reflect === "undefined" || !Reflect.getMetadata) {
+  throw new Error("tsyringe requires a reflect polyfill. Please add 'import \"reflect-metadata\"' to the top of your entry point.");
+}
+
+exports.Lifecycle = lifecycle.default;
+exports.container = dependencyContainer.instance;

package/dist/cjs/node_modules/tsyringe/dist/esm5/interceptors.js

@@ -0,0 +1,32 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib_es6 = require('../../../tslib/tslib.es6.js');
+var registryBase = require('./registry-base.js');
+
+var PreResolutionInterceptors = function (_super) {
+  tslib_es6.__extends(PreResolutionInterceptors, _super);
+  function PreResolutionInterceptors() {
+    return _super !== null && _super.apply(this, arguments) || this;
+  }
+  return PreResolutionInterceptors;
+}(registryBase.default);
+var PostResolutionInterceptors = function (_super) {
+  tslib_es6.__extends(PostResolutionInterceptors, _super);
+  function PostResolutionInterceptors() {
+    return _super !== null && _super.apply(this, arguments) || this;
+  }
+  return PostResolutionInterceptors;
+}(registryBase.default);
+var Interceptors = function () {
+  function Interceptors() {
+    this.preResolution = new PreResolutionInterceptors();
+    this.postResolution = new PostResolutionInterceptors();
+  }
+  return Interceptors;
+}();
+
+exports.PostResolutionInterceptors = PostResolutionInterceptors;
+exports.PreResolutionInterceptors = PreResolutionInterceptors;
+exports.default = Interceptors;

package/dist/cjs/node_modules/tsyringe/dist/esm5/lazy-helpers.js

@@ -0,0 +1,43 @@
+'use strict';
+
+var tslib_es6 = require('../../../tslib/tslib.es6.js');
+
+var DelayedConstructor = function () {
+  function DelayedConstructor(wrap) {
+    this.wrap = wrap;
+    this.reflectMethods = ["get", "getPrototypeOf", "setPrototypeOf", "getOwnPropertyDescriptor", "defineProperty", "has", "set", "deleteProperty", "apply", "construct", "ownKeys"];
+  }
+  DelayedConstructor.prototype.createProxy = function (createObject) {
+    var _this = this;
+    var target = {};
+    var init = false;
+    var value;
+    var delayedObject = function () {
+      if (!init) {
+        value = createObject(_this.wrap());
+        init = true;
+      }
+      return value;
+    };
+    return new Proxy(target, this.createHandler(delayedObject));
+  };
+  DelayedConstructor.prototype.createHandler = function (delayedObject) {
+    var handler = {};
+    var install = function (name) {
+      handler[name] = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+          args[_i] = arguments[_i];
+        }
+        args[0] = delayedObject();
+        var method = Reflect[name];
+        return method.apply(void 0, tslib_es6.__spread(args));
+      };
+    };
+    this.reflectMethods.forEach(install);
+    return handler;
+  };
+  return DelayedConstructor;
+}();
+
+exports.DelayedConstructor = DelayedConstructor;

package/dist/cjs/node_modules/tsyringe/dist/esm5/providers/class-provider.js

@@ -0,0 +1,7 @@
+'use strict';
+
+function isClassProvider(provider) {
+  return !!provider.useClass;
+}
+
+exports.isClassProvider = isClassProvider;

package/dist/cjs/node_modules/tsyringe/dist/esm5/providers/factory-provider.js

@@ -0,0 +1,7 @@
+'use strict';
+
+function isFactoryProvider(provider) {
+  return !!provider.useFactory;
+}
+
+exports.isFactoryProvider = isFactoryProvider;

package/dist/cjs/node_modules/tsyringe/dist/esm5/providers/injection-token.js

@@ -0,0 +1,21 @@
+'use strict';
+
+var lazyHelpers = require('../lazy-helpers.js');
+
+function isNormalToken(token) {
+  return typeof token === "string" || typeof token === "symbol";
+}
+function isTokenDescriptor(descriptor) {
+  return typeof descriptor === "object" && "token" in descriptor && "multiple" in descriptor;
+}
+function isTransformDescriptor(descriptor) {
+  return typeof descriptor === "object" && "token" in descriptor && "transform" in descriptor;
+}
+function isConstructorToken(token) {
+  return typeof token === "function" || token instanceof lazyHelpers.DelayedConstructor;
+}
+
+exports.isConstructorToken = isConstructorToken;
+exports.isNormalToken = isNormalToken;
+exports.isTokenDescriptor = isTokenDescriptor;
+exports.isTransformDescriptor = isTransformDescriptor;

package/dist/cjs/node_modules/tsyringe/dist/esm5/providers/provider.js

@@ -0,0 +1,12 @@
+'use strict';
+
+var classProvider = require('./class-provider.js');
+var valueProvider = require('./value-provider.js');
+var tokenProvider = require('./token-provider.js');
+var factoryProvider = require('./factory-provider.js');
+
+function isProvider(provider) {
+  return classProvider.isClassProvider(provider) || valueProvider.isValueProvider(provider) || tokenProvider.isTokenProvider(provider) || factoryProvider.isFactoryProvider(provider);
+}
+
+exports.isProvider = isProvider;

package/dist/cjs/node_modules/tsyringe/dist/esm5/providers/token-provider.js

@@ -0,0 +1,7 @@
+'use strict';
+
+function isTokenProvider(provider) {
+  return !!provider.useToken;
+}
+
+exports.isTokenProvider = isTokenProvider;

package/dist/cjs/node_modules/tsyringe/dist/esm5/providers/value-provider.js

@@ -0,0 +1,7 @@
+'use strict';
+
+function isValueProvider(provider) {
+  return provider.useValue != undefined;
+}
+
+exports.isValueProvider = isValueProvider;

package/dist/cjs/node_modules/tsyringe/dist/esm5/reflection-helpers.js

@@ -0,0 +1,14 @@
+'use strict';
+
+var INJECTION_TOKEN_METADATA_KEY = "injectionTokens";
+function getParamInfo(target) {
+  var params = Reflect.getMetadata("design:paramtypes", target) || [];
+  var injectionTokens = Reflect.getOwnMetadata(INJECTION_TOKEN_METADATA_KEY, target) || {};
+  Object.keys(injectionTokens).forEach(function (key) {
+    params[+key] = injectionTokens[key];
+  });
+  return params;
+}
+
+exports.INJECTION_TOKEN_METADATA_KEY = INJECTION_TOKEN_METADATA_KEY;
+exports.getParamInfo = getParamInfo;