first commit

node_modules/tsyringe/dist/typings/decorators/auto-injectable.d.ts

@@ -0,0 +1,11 @@
+import constructor from "../types/constructor";
+/**
+ * Class decorator factory that replaces the decorated class' constructor with
+ * a parameterless constructor that has dependencies auto-resolved
+ *
+ * Note: Resolution is performed using the global container
+ *
+ * @return {Function} The class decorator
+ */
+declare function autoInjectable(): (target: constructor<any>) => any;
+export default autoInjectable;

node_modules/tsyringe/dist/typings/decorators/index.d.ts

@@ -0,0 +1,9 @@
+export { default as autoInjectable } from "./auto-injectable";
+export { default as inject } from "./inject";
+export { default as injectable } from "./injectable";
+export { default as registry } from "./registry";
+export { default as singleton } from "./singleton";
+export { default as injectAll } from "./inject-all";
+export { default as injectAllWithTransform } from "./inject-all-with-transform";
+export { default as injectWithTransform } from "./inject-with-transform";
+export { default as scoped } from "./scoped";

node_modules/tsyringe/dist/typings/decorators/inject-all-with-transform.d.ts

@@ -0,0 +1,9 @@
+import InjectionToken from "../providers/injection-token";
+import Transform from "../types/transform";
+/**
+ * Parameter decorator factory that allows for interface information to be stored in the constructor's metadata
+ *
+ * @return {Function} The parameter decorator
+ */
+declare function injectAllWithTransform(token: InjectionToken<any>, transformer: InjectionToken<Transform<[any], any>>, ...args: any[]): (target: any, propertyKey: string | symbol | undefined, parameterIndex: number) => any;
+export default injectAllWithTransform;

node_modules/tsyringe/dist/typings/decorators/inject-all.d.ts

@@ -0,0 +1,10 @@
+import InjectionToken from "../providers/injection-token";
+/**
+ * Parameter decorator factory that allows for interface information to be stored in the constructor's metadata
+ *
+ * @return {Function} The parameter decorator
+ */
+declare function injectAll(token: InjectionToken<any>, options?: {
+    isOptional?: boolean;
+}): (target: any, propertyKey: string | symbol | undefined, parameterIndex: number) => any;
+export default injectAll;

node_modules/tsyringe/dist/typings/decorators/inject-with-transform.d.ts

@@ -0,0 +1,11 @@
+import { InjectionToken } from "../providers";
+import Transform from "../types/transform";
+/**
+ * Parameter decorator factory that allows for interface information to be stored in the constructor's metadata with a transform token
+ * @param token The token of the object to be resolved
+ * @param transformer The token of the transform object
+ * @param args Arguments to be passed to the transform method on the transformer
+ * @returns The parameter decorator
+ */
+declare function injectWithTransform(token: InjectionToken<any>, transformer: InjectionToken<Transform<any, any>>, ...args: any[]): (target: any, propertyKey: string | symbol | undefined, parameterIndex: number) => any;
+export default injectWithTransform;

node_modules/tsyringe/dist/typings/decorators/inject.d.ts

@@ -0,0 +1,10 @@
+import InjectionToken from "../providers/injection-token";
+/**
+ * Parameter decorator factory that allows for interface information to be stored in the constructor's metadata
+ *
+ * @return {Function} The parameter decorator
+ */
+declare function inject(token: InjectionToken<any>, options?: {
+    isOptional?: boolean;
+}): (target: any, propertyKey: string | symbol | undefined, parameterIndex: number) => any;
+export default inject;

node_modules/tsyringe/dist/typings/decorators/injectable.d.ts

@@ -0,0 +1,12 @@
+import constructor from "../types/constructor";
+import InjectionToken from "../providers/injection-token";
+/**
+ * Class decorator factory that allows the class' dependencies to be injected
+ * at runtime.
+ *
+ * @return {Function} The class decorator
+ */
+declare function injectable<T>(options?: {
+    token?: InjectionToken<T> | InjectionToken<T>[];
+}): (target: constructor<T>) => void;
+export default injectable;

node_modules/tsyringe/dist/typings/decorators/registry.d.ts

@@ -0,0 +1,13 @@
+import Provider from "../providers/provider";
+import InjectionToken from "../providers/injection-token";
+import RegistrationOptions from "../types/registration-options";
+/**
+ * Class decorator factory that allows constructor dependencies to be registered at runtime.
+ *
+ * @return {Function} The class decorator
+ */
+declare function registry(registrations?: ({
+    token: InjectionToken;
+    options?: RegistrationOptions;
+} & Provider<any>)[]): (target: any) => any;
+export default registry;

node_modules/tsyringe/dist/typings/decorators/scoped.d.ts

@@ -0,0 +1,10 @@
+import constructor from "../types/constructor";
+import { InjectionToken } from "../providers";
+import Lifecycle from "../types/lifecycle";
+/**
+ * Class decorator factory that registers the class as a scoped dependency within
+ * the global container.
+ *
+ * @return The class decorator
+ */
+export default function scoped<T>(lifecycle: Lifecycle.ContainerScoped | Lifecycle.ResolutionScoped, token?: InjectionToken<T>): (target: constructor<T>) => void;

node_modules/tsyringe/dist/typings/decorators/singleton.d.ts

@@ -0,0 +1,9 @@
+import constructor from "../types/constructor";
+/**
+ * Class decorator factory that registers the class as a singleton within
+ * the global container.
+ *
+ * @return {Function} The class decorator
+ */
+declare function singleton<T>(): (target: constructor<T>) => void;
+export default singleton;

node_modules/tsyringe/dist/typings/dependency-container.d.ts

@@ -0,0 +1,14 @@
+import DependencyContainer from "./types/dependency-container";
+import Provider from "./providers/provider";
+import InjectionToken, { TokenDescriptor } from "./providers/injection-token";
+import RegistrationOptions from "./types/registration-options";
+import constructor from "./types/constructor";
+export declare type Registration<T = any> = {
+    provider: Provider<T>;
+    options: RegistrationOptions;
+    instance?: T;
+};
+export declare type ParamInfo = TokenDescriptor | InjectionToken<any>;
+export declare const typeInfo: Map<constructor<any>, ParamInfo[]>;
+export declare const instance: DependencyContainer;
+export default instance;

node_modules/tsyringe/dist/typings/error-helpers.d.ts

@@ -0,0 +1,2 @@
+import constructor from "./types/constructor";
+export declare function formatErrorCtor(ctor: constructor<any>, paramIdx: number, error: Error): string;

node_modules/tsyringe/dist/typings/factories/factory-function.d.ts

@@ -0,0 +1,3 @@
+import DependencyContainer from "../types/dependency-container";
+declare type FactoryFunction<T> = (dependencyContainer: DependencyContainer) => T;
+export default FactoryFunction;

node_modules/tsyringe/dist/typings/factories/index.d.ts

@@ -0,0 +1,4 @@
+export { default as FactoryFunction } from "./factory-function";
+export { default as instanceCachingFactory } from "./instance-caching-factory";
+export { default as instancePerContainerCachingFactory } from "./instance-per-container-caching-factory";
+export { default as predicateAwareClassFactory } from "./predicate-aware-class-factory";

node_modules/tsyringe/dist/typings/factories/instance-caching-factory.d.ts

@@ -0,0 +1,2 @@
+import FactoryFunction from "./factory-function";
+export default function instanceCachingFactory<T>(factoryFunc: FactoryFunction<T>): FactoryFunction<T>;

node_modules/tsyringe/dist/typings/factories/instance-per-container-caching-factory.d.ts

@@ -0,0 +1,2 @@
+import FactoryFunction from "./factory-function";
+export default function instancePerContainerCachingFactory<T>(factoryFunc: FactoryFunction<T>): FactoryFunction<T>;

node_modules/tsyringe/dist/typings/factories/predicate-aware-class-factory.d.ts

@@ -0,0 +1,4 @@
+import DependencyContainer from "../types/dependency-container";
+import constructor from "../types/constructor";
+import FactoryFunction from "./factory-function";
+export default function predicateAwareClassFactory<T>(predicate: (dependencyContainer: DependencyContainer) => boolean, trueConstructor: constructor<T>, falseConstructor: constructor<T>, useCaching?: boolean): FactoryFunction<T>;

node_modules/tsyringe/dist/typings/index.d.ts

@@ -0,0 +1,6 @@
+export { DependencyContainer, Disposable, Lifecycle, RegistrationOptions, Frequency } from "./types";
+export * from "./decorators";
+export * from "./factories";
+export * from "./providers";
+export { delay } from "./lazy-helpers";
+export { instance as container } from "./dependency-container";

node_modules/tsyringe/dist/typings/interceptors.d.ts

@@ -0,0 +1,19 @@
+import RegistryBase from "./registry-base";
+import { InterceptionOptions } from "./types";
+import { PostResolutionInterceptorCallback, PreResolutionInterceptorCallback } from "./types/dependency-container";
+export declare type PreResolutionInterceptor = {
+    callback: PreResolutionInterceptorCallback;
+    options: InterceptionOptions;
+};
+export declare type PostResolutionInterceptor = {
+    callback: PostResolutionInterceptorCallback;
+    options: InterceptionOptions;
+};
+export declare class PreResolutionInterceptors extends RegistryBase<PreResolutionInterceptor> {
+}
+export declare class PostResolutionInterceptors extends RegistryBase<PostResolutionInterceptor> {
+}
+export default class Interceptors {
+    preResolution: PreResolutionInterceptors;
+    postResolution: PostResolutionInterceptors;
+}

node_modules/tsyringe/dist/typings/lazy-helpers.d.ts

@@ -0,0 +1,9 @@
+import constructor from "./types/constructor";
+export declare class DelayedConstructor<T> {
+    private wrap;
+    private reflectMethods;
+    constructor(wrap: () => constructor<T>);
+    createProxy(createObject: (ctor: constructor<T>) => T): T;
+    private createHandler;
+}
+export declare function delay<T>(wrappedConstructor: () => constructor<T>): DelayedConstructor<T>;

node_modules/tsyringe/dist/typings/providers/class-provider.d.ts

@@ -0,0 +1,7 @@
+import constructor from "../types/constructor";
+import Provider from "./provider";
+import { DelayedConstructor } from "../lazy-helpers";
+export default interface ClassProvider<T> {
+    useClass: constructor<T> | DelayedConstructor<T>;
+}
+export declare function isClassProvider<T>(provider: Provider<T>): provider is ClassProvider<any>;

node_modules/tsyringe/dist/typings/providers/factory-provider.d.ts

@@ -0,0 +1,11 @@
+import DependencyContainer from "../types/dependency-container";
+import Provider from "./provider";
+/**
+ * Provide a dependency using a factory.
+ * Unlike the other providers, this does not support instance caching. If
+ * you need instance caching, your factory method must implement it.
+ */
+export default interface FactoryProvider<T> {
+    useFactory: (dependencyContainer: DependencyContainer) => T;
+}
+export declare function isFactoryProvider<T>(provider: Provider<T>): provider is FactoryProvider<any>;

node_modules/tsyringe/dist/typings/providers/index.d.ts

@@ -0,0 +1,6 @@
+export { default as ClassProvider, isClassProvider } from "./class-provider";
+export { default as FactoryProvider, isFactoryProvider } from "./factory-provider";
+export { default as InjectionToken, isNormalToken } from "./injection-token";
+export { default as Provider } from "./provider";
+export { default as TokenProvider, isTokenProvider } from "./token-provider";
+export { default as ValueProvider, isValueProvider } from "./value-provider";

node_modules/tsyringe/dist/typings/providers/injection-token.d.ts

@@ -0,0 +1,19 @@
+import constructor from "../types/constructor";
+import { DelayedConstructor } from "../lazy-helpers";
+import Transform from "../types/transform";
+declare type InjectionToken<T = any> = constructor<T> | string | symbol | DelayedConstructor<T>;
+export declare function isNormalToken(token?: InjectionToken<any>): token is string | symbol;
+export declare function isTokenDescriptor(descriptor: any): descriptor is TokenDescriptor;
+export declare function isTransformDescriptor(descriptor: any): descriptor is TransformDescriptor;
+export declare function isConstructorToken(token?: InjectionToken<any>): token is constructor<any> | DelayedConstructor<any>;
+export interface TokenDescriptor {
+    token: InjectionToken<any>;
+    multiple: boolean;
+    isOptional?: boolean;
+}
+export interface TransformDescriptor {
+    token: InjectionToken<any>;
+    transform: InjectionToken<Transform<any, any>>;
+    transformArgs: any[];
+}
+export default InjectionToken;

node_modules/tsyringe/dist/typings/providers/provider.d.ts

@@ -0,0 +1,7 @@
+import ClassProvider from "./class-provider";
+import ValueProvider from "./value-provider";
+import TokenProvider from "./token-provider";
+import FactoryProvider from "./factory-provider";
+declare type Provider<T = any> = ClassProvider<T> | ValueProvider<T> | TokenProvider<T> | FactoryProvider<T>;
+export declare function isProvider(provider: any): provider is Provider;
+export default Provider;

node_modules/tsyringe/dist/typings/providers/token-provider.d.ts

@@ -0,0 +1,6 @@
+import InjectionToken from "./injection-token";
+import Provider from "./provider";
+export default interface TokenProvider<T> {
+    useToken: InjectionToken<T>;
+}
+export declare function isTokenProvider<T>(provider: Provider<T>): provider is TokenProvider<any>;

node_modules/tsyringe/dist/typings/providers/value-provider.d.ts

@@ -0,0 +1,5 @@
+import Provider from "./provider";
+export default interface ValueProvider<T> {
+    useValue: T;
+}
+export declare function isValueProvider<T>(provider: Provider<T>): provider is ValueProvider<T>;

node_modules/tsyringe/dist/typings/reflection-helpers.d.ts

@@ -0,0 +1,10 @@
+import constructor from "./types/constructor";
+import InjectionToken from "./providers/injection-token";
+import { ParamInfo } from "./dependency-container";
+import Transform from "./types/transform";
+export declare const INJECTION_TOKEN_METADATA_KEY = "injectionTokens";
+export declare function getParamInfo(target: constructor<any>): ParamInfo[];
+export declare function defineInjectionTokenMetadata(data: any, transform?: {
+    transformToken: InjectionToken<Transform<any, any>>;
+    args: any[];
+}): (target: any, propertyKey: string | symbol | undefined, parameterIndex: number) => any;

node_modules/tsyringe/dist/typings/registry-base.d.ts

@@ -0,0 +1,12 @@
+import { InjectionToken } from ".";
+export default abstract class RegistryBase<T> {
+    protected _registryMap: Map<InjectionToken<any>, T[]>;
+    entries(): IterableIterator<[InjectionToken<any>, T[]]>;
+    getAll(key: InjectionToken<any>): T[];
+    get(key: InjectionToken<any>): T | null;
+    set(key: InjectionToken<any>, value: T): void;
+    setAll(key: InjectionToken<any>, value: T[]): void;
+    has(key: InjectionToken<any>): boolean;
+    clear(): void;
+    private ensure;
+}

node_modules/tsyringe/dist/typings/registry.d.ts

@@ -0,0 +1,4 @@
+import { Registration } from "./dependency-container";
+import RegistryBase from "./registry-base";
+export default class Registry extends RegistryBase<Registration> {
+}

node_modules/tsyringe/dist/typings/resolution-context.d.ts

@@ -0,0 +1,4 @@
+import { Registration } from "./dependency-container";
+export default class ResolutionContext {
+    scopedResolutions: Map<Registration, any>;
+}

node_modules/tsyringe/dist/typings/types/constructor.d.ts

@@ -0,0 +1,5 @@
+/** Constructor type */
+declare type constructor<T> = {
+    new (...args: any[]): T;
+};
+export default constructor;

node_modules/tsyringe/dist/typings/types/dependency-container.d.ts

@@ -0,0 +1,77 @@
+import FactoryProvider from "../providers/factory-provider";
+import InjectionToken from "../providers/injection-token";
+import TokenProvider from "../providers/token-provider";
+import ValueProvider from "../providers/value-provider";
+import ClassProvider from "../providers/class-provider";
+import constructor from "./constructor";
+import RegistrationOptions from "./registration-options";
+import Disposable from "./disposable";
+import InterceptorOptions from "./interceptor-options";
+export declare type ResolutionType = "Single" | "All";
+export interface PreResolutionInterceptorCallback<T = any> {
+    /**
+     * @param token The InjectionToken that was intercepted
+     * @param resolutionType The type of resolve that was called (i.e. All or Single)
+     */
+    (token: InjectionToken<T>, resolutionType: ResolutionType): void;
+}
+export interface PostResolutionInterceptorCallback<T = any> {
+    /**
+     * @param token The InjectionToken that was intercepted
+     * @param result The object that was resolved from the container
+     * @param resolutionType The type of resolve that was called (i.e. All or Single)
+     */
+    (token: InjectionToken<T>, result: T | T[], resolutionType: ResolutionType): void;
+}
+export default interface DependencyContainer extends Disposable {
+    register<T>(token: InjectionToken<T>, provider: ValueProvider<T>): DependencyContainer;
+    register<T>(token: InjectionToken<T>, provider: FactoryProvider<T>): DependencyContainer;
+    register<T>(token: InjectionToken<T>, provider: TokenProvider<T>, options?: RegistrationOptions): DependencyContainer;
+    register<T>(token: InjectionToken<T>, provider: ClassProvider<T>, options?: RegistrationOptions): DependencyContainer;
+    register<T>(token: InjectionToken<T>, provider: constructor<T>, options?: RegistrationOptions): DependencyContainer;
+    registerSingleton<T>(from: InjectionToken<T>, to: InjectionToken<T>): DependencyContainer;
+    registerSingleton<T>(token: constructor<T>): DependencyContainer;
+    registerType<T>(from: InjectionToken<T>, to: InjectionToken<T>): DependencyContainer;
+    registerInstance<T>(token: InjectionToken<T>, instance: T): DependencyContainer;
+    /**
+     * Resolve a token into an instance
+     *
+     * @param token The dependency token
+     * @return An instance of the dependency
+     */
+    resolve<T>(token: InjectionToken<T>): T;
+    resolveAll<T>(token: InjectionToken<T>): T[];
+    /**
+     * Check if the given dependency is registered
+     *
+     * @param token The token to check
+     * @param recursive Should parent containers be checked?
+     * @return Whether or not the token is registered
+     */
+    isRegistered<T>(token: InjectionToken<T>, recursive?: boolean): boolean;
+    /**
+     * Clears all registered tokens
+     */
+    reset(): void;
+    clearInstances(): void;
+    createChildContainer(): DependencyContainer;
+    /**
+     * Registers a callback that is called when a specific injection token is resolved
+     * @param token The token to intercept
+     * @param callback The callback that is called before the token is resolved
+     * @param options Options for under what circumstances the callback will be called
+     */
+    beforeResolution<T>(token: InjectionToken<T>, callback: PreResolutionInterceptorCallback<T>, options?: InterceptorOptions): void;
+    /**
+     * Registers a callback that is called after a successful resolution of the token
+     * @param token The token to intercept
+     * @param callback The callback that is called after the token is resolved
+     * @param options Options for under what circumstances the callback will be called
+     */
+    afterResolution<T>(token: InjectionToken<T>, callback: PostResolutionInterceptorCallback<T>, options?: InterceptorOptions): void;
+    /**
+     * Calls `.dispose()` on all disposable instances created by the container.
+     * After calling this, the container may no longer be used.
+     */
+    dispose(): Promise<void> | void;
+}

node_modules/tsyringe/dist/typings/types/dictionary.d.ts

@@ -0,0 +1,4 @@
+declare type Dictionary<T> = {
+    [key: string]: T;
+};
+export default Dictionary;

node_modules/tsyringe/dist/typings/types/disposable.d.ts

@@ -0,0 +1,4 @@
+export default interface Disposable {
+    dispose(): Promise<void> | void;
+}
+export declare function isDisposable(value: any): value is Disposable;

node_modules/tsyringe/dist/typings/types/frequency.d.ts

@@ -0,0 +1,2 @@
+declare type Frequency = "Always" | "Once";
+export default Frequency;

node_modules/tsyringe/dist/typings/types/index.d.ts

@@ -0,0 +1,9 @@
+export { default as constructor } from "./constructor";
+export { default as DependencyContainer } from "./dependency-container";
+export { default as Dictionary } from "./dictionary";
+export { default as RegistrationOptions } from "./registration-options";
+export { default as Lifecycle } from "./lifecycle";
+export { default as Disposable } from "./disposable";
+export { default as InterceptionOptions } from "./interceptor-options";
+export { default as Frequency } from "./frequency";
+export { default as Transform } from "./transform";

node_modules/tsyringe/dist/typings/types/interceptor-options.d.ts

@@ -0,0 +1,5 @@
+import Frequency from "./frequency";
+declare type InterceptorOptions = {
+    frequency: Frequency;
+};
+export default InterceptorOptions;

node_modules/tsyringe/dist/typings/types/lifecycle.d.ts

@@ -0,0 +1,7 @@
+declare enum Lifecycle {
+    Transient = 0,
+    Singleton = 1,
+    ResolutionScoped = 2,
+    ContainerScoped = 3
+}
+export default Lifecycle;

node_modules/tsyringe/dist/typings/types/registration-options.d.ts

@@ -0,0 +1,9 @@
+import Lifecycle from "./lifecycle";
+declare type RegistrationOptions = {
+    /**
+     * Customize the lifecycle of the registration
+     * See https://github.com/microsoft/tsyringe#available-scopes for more information
+     */
+    lifecycle: Lifecycle;
+};
+export default RegistrationOptions;

node_modules/tsyringe/dist/typings/types/transform.d.ts

@@ -0,0 +1,4 @@
+interface Transform<TIn, TOut> {
+    transform: (incoming: TIn, ...args: any[]) => TOut;
+}
+export default Transform;