ts-ioc-container 23.2.11 → 23.3.1

package/README.md

@@ -19,13 +19,20 @@
 
 ## Install
 ```shell script
-npm install ts-ioc-container ts-constructor-injector reflect-metadata
+npm install ts-ioc-container reflect-metadata
 ```
 ```shell script
-yarn add ts-ioc-container ts-constructor-injector reflect-metadata
+yarn add ts-ioc-container reflect-metadata
 ```
 
-## tsconfig.json
+## Setup
+### reflect-metadata
+Add it in main file of your project. It should be first line of code.
+```typescript
+import 'reflect-metadata';
+```
+
+### tsconfig.json
 ```json
 {
   "compilerOptions": {
@@ -35,21 +42,103 @@ yarn add ts-ioc-container ts-constructor-injector reflect-metadata
 }
 ```
 
+## Container
+Container consists of:
 
-## Injector
-As long as injector is not part of container, you can implement injection on your choice (simple, proxy, based on reflection).
+- Injector - injects dependencies to constructor
+- Providers - templates that create instances of dependencies
 
-### Reflection injector (recommended)
+### Basic usage
 
 ```typescript
-import { Container, IContainer, IInjector, Provider, by } from "ts-request-mediator";
-import { inject, resolve } from "ts-constructor-injector";
+import 'reflect-metadata';
+import { Container } from "ts-ioc-container";
+
+class Logger {
+  public name = 'Logger';
+}
 
-const injector: IInjector = {
-  resolve<T>(container: IContainer, Target: constructor<T>, ...deps: unknown[]): T {
-    return resolve(container)(Target, ...deps);
-  },
-};
+class App {
+  constructor(@inject(by('ILogger')) public logger: ILogger) {
+  }
+}
+
+const container = new Container(new ReflectionInjector()).register('ILogger', Provider.fromClass(Logger));
+container.resolve(App).resolve.logger.name === 'Logger'; // true
+
+container.dispose();
+```
+
+### Scopes
+- scope - is a container that can be created from another container. It's a sub-container.
+- NOTICE: when you create a scope of container then all providers are cloned to new scope. Every provider has method `clone` that clones itself.
+
+```typescript
+import { Container, ReflectionInjector } from "ts-ioc-container";
+
+const container = new Container(new ReflectionInjector());
+const scope = container.createScope();
+```
+
+### Tags
+
+- tag - is a string that can be used mark each container and scope
+- every provider can be registered per certain tags and cannot be resolved from container with other tags. Only from parent one with certain tags.
+- NOTICE: when you create a scope of container with tags which not includes in provider tags then this provider will not be cloned to new scope.
+
+```typescript
+import { Container, perTags, ReflectionInjector } from "ts-ioc-container";
+
+const container = new Container(new ReflectionInjector(), { tags: ['root'] }).register('ILogger', Provider.fromClass(Logger).pipe(perTags('root')));
+const scope = container.createScope(['child']);
+
+scope.resolve('ILogger'); // it will be resolved from container, not from scope
+```
+
+### Instances
+- you can get instances from container and scope which were created by injector
+
+```typescript
+import { Container, ReflectionInjector } from "ts-ioc-container";
+
+const container = new Container(new ReflectionInjector()).register('ILogger', Provider.fromClass(Logger));
+const scope = container.createScope();
+
+const logger1 = container.resolve('ILogger');
+const logger2 = scope.resolve('ILogger');
+
+expect(scope.getInstances().length).toBe(1);
+expect(container.getInstances().length).toBe(2);
+```
+
+### Disposing
+- container can be disposed
+- when container is disposed then all scopes are disposed too
+- when container is disposed then it unregisters all providers and remove all instances
+
+```typescript
+import { asSingleton, Container, perTags, ReflectionInjector, ContainerDisposedError } from "ts-ioc-container";
+
+const container = new Container(new ReflectionInjector(), { tags: ['root'] }).register('ILogger', Provider.fromClass(Logger));
+const scope = container.createScope(['child']);
+
+const logger = scope.resolve('ILogger');
+container.dispose();
+
+expect(() => scope.resolve('ILogger')).toThrow(ContainerDisposedError);
+expect(() => container.resolve('ILogger')).toThrow(ContainerDisposedError);
+expect(container.getInstances().length).toBe(0);
+```
+
+## Injectors
+- `ReflectionInjector` - injects dependencies using `@inject` decorator
+- `ProxyInjector` - injects dependencies as dictionary `Record<string, unknown>`
+- `SimpleInjector` - just passes container to constructor with others arguments
+
+### Reflection injector
+
+```typescript
+import { Container, IContainer, IInjector, Provider, by, inject, resolve } from "ts-ioc-container";
 
 class Logger implements ILogger {
   info(message: string) {
@@ -58,15 +147,19 @@ class Logger implements ILogger {
 }
 
 class App {
-  constructor(@inject(by('ILogger')) private logger: ILogger) {
+  constructor(@inject((container, ...args) => container.resolve('ILogger', ...args)) private logger: ILogger) {
   }
 
+  // OR
+  // constructor(@inject(by('ILogger')) private logger: ILogger) {
+  // }
+
   run() {
     this.logger.info('Hello world');
   }
 }
 
-const container = new Container(injector)
+const container = new Container(new ReflectionInjector())
   .register('ILogger', Provider.fromClass(Logger));
 
 const app = container.resolve(App);
@@ -76,13 +169,7 @@ app.run();
 ### Simple injector
 
 ```typescript
-import { IContainer } from "ts-request-mediator";
-
-const injector: IInjector = {
-  resolve<T>(container: IContainer, Target: constructor<T>, ...deps: unknown[]): T {
-    return new Target(container, ...deps);
-  },
-};
+import { SimpleInjector, IContainer } from "ts-ioc-container";
 
 class Logger implements ILogger {
   info(message: string) {
@@ -96,13 +183,13 @@ class App {
   constructor(private container: IContainer) {
     this.logger = container.resolve('ILogger');
   }
-  
+
   run() {
     this.logger.info('Hello world');
   }
 }
 
-const container = new Container(injector)
+const container = new Container(new SimpleInjector())
   .register('ILogger', Provider.fromClass(Logger));
 
 const app = container.resolve(App);
@@ -112,24 +199,7 @@ app.run();
 ### Proxy injector
 
 ```typescript
-import { IContainer } from "ts-request-mediator";
-
-const injector: IInjector = {
-  resolve<T>(container: IContainer, Target: constructor<T>, ...deps: unknown[]): T {
-    const args = deps.reduce((acc, it) => ({ ...acc, ...it }), {});
-    const proxy = new Proxy(
-      {},
-      {
-        // eslint-disable-next-line @typescript-eslint/ban-types
-        get(target: {}, prop: string | symbol): any {
-          // eslint-disable-next-line no-prototype-builtins
-          return args.hasOwnProperty(prop) ? args[prop] : container.resolve(prop);
-        },
-      },
-    );
-    return new Target(proxy);
-  },
-};
+import { ProxyInjector, IContainer } from "ts-ioc-container";
 
 class Logger implements ILogger {
   info(message: string) {
@@ -140,182 +210,142 @@ class Logger implements ILogger {
 class App {
   private logger: ILogger;
 
-  constructor({logger}: {logger: ILogger}) {
+  constructor({ logger }: { logger: ILogger }) {
     this.logger = logger;
   }
-  
+
   run() {
     this.logger.info('Hello world');
   }
 }
 
-const container = new Container(injector)
+const container = new Container(new ProxyInjector())
   .register('logger', Provider.fromClass(Logger));
 
 const app = container.resolve(App);
 app.run();
 ```
 
-## Provider
+## Providers
+All providers are registered in container and cloned for every sub-scope.
+
+- `Provider` - basic provider
+- `SingletonProvider` - provider that creates only one instance in every scope where it's resolved
+- `TaggedProvider` - provider that can be resolved only from container with certain tags and their sub scopes
+- `ArgsProvider` - provider that encapsulates arguments to pass it to constructor.
 
-- `Provider.fromClass` - creates dependency provider from class
-- `.pipe` - decorates provider by features and returns new provider
-- `asSingleton()` - makes provider singleton (singleton in every scope)
-- `perTags(...tags: string[])` - makes provider available only in scope with certain tags and their sub scopes
-- `withArgs(...args: unknown[])` - passes arguments to constructor
-- `withArgsFn(fn: (scope: IContainer) => unknown[])` - passes arguments to constructor as function result
+### Provider
+
+From function
 
 ```typescript
-import { Provider, asSingleton, perTags, withArgs, withArgsFn } from "ts-request-mediator";
+import { Provider } from "ts-ioc-container";
 
-const container = new Container(injector, { tags: ['root'] });
-container.register('ILogger', new Provider((container, ...args) => new Logger(...args)));
+container.register('ILogger', new Provider((container, ...args) => new Logger(container, ...args)));
+```
 
-// Available only in root scope and all his children
-container.register('ILogger', Provider.fromClass(Logger).pipe(perTags('root')));
+From class
 
-// Singleton per root tag and all his children
-container.register('ILogger', Provider.fromClass(Logger).pipe(asSingleton(), perTags('root')));
+```typescript
+import { Provider } from "ts-ioc-container";
 
-// singleton for scope with tag1 or tag2
-container.register('ILogger', Provider.fromClass(Logger).pipe(asSingleton(), perTags('tag1', 'tag2')));
+container.register('ILogger', Provider.fromClass(Logger));
+```
 
-// singleton in every scope
-container.register('ILogger', Provider.fromClass(Logger).pipe(withArgs('dev'), asSingleton()));
+From value
 
-// singleton in every scope
-container.register('ILogger', Provider.fromClass(Logger).pipe(withArgsFn((scope) => [scope.resolve('isTestEnv') ? 'dev' : 'prod']), asSingleton()));
+```typescript
+import { Provider } from "ts-ioc-container";
 
 container.register('ILogger', Provider.fromValue(new Logger()));
 ```
 
-## Registration module (Provider + DependencyKey)
+`pipe` - decorates provider by other providers
 
 ```typescript
-import { asSingleton, perTags, forKey, Registration } from "ts-request-mediator";
+import { asSingleton, perTags, Provider, SingletonProvider, TaggedProvider } from "ts-ioc-container";
 
-@forKey('ILogger')
+container.register('ILogger', Provider.fromClass(Logger).pipe((provider) => new SingletonProvider(provider)), (provider) => new TaggedProvider(provider, ['root']));
+
+// OR
+container.register('ILogger', Provider.fromClass(Logger).pipe(asSingleton(), perTags('root')));
+
+// OR
 @provider(asSingleton(), perTags('root'))
 class Logger {
-  info(message: string) {
-    console.log(message);
-  }
 }
 
-const container = new Container(injector, { tags: ['root'] })
-  .add(Registration.fromClass(Logger));
-const logger = container.resolve<ILogger>('ILogger');
-logger.info('Hello world');
+container.register('ILogger', Provider.fromClass(Logger));
 ```
 
-## Decorators
+### Singleton provider
 
-```typescript
-import { asSingleton, perTags, forKey, by, Registration } from "ts-request-mediator";
-import { inject } from "ts-constructor-injector";
+- Singleton provider creates only one instance in every scope where it's resolved.
+- NOTICE: if you create a scope 'A' of container 'root' then Logger of A !== Logger of root.
 
-@forKey('IEngine')
-@provider(asSingleton(), perTags('root'))
-class Engine {
-  constructor(@inject(by('ILogger')) private logger: ILogger) {
-  }
-}
+```typescript
+import { Provider, SingletonProvider, asSingleton } from "ts-ioc-container";
 
+container.register('ILogger', Provider.fromClass(Logger).pipe((provider) => new SingletonProvider(provider)));
 // OR
+container.register('ILogger', Provider.fromClass(Logger).pipe(asSingleton()));
 
-const perRoot = provider(asSingleton(), perTags('root'))
-
-@perRoot
-@forKey('IEngine')
-class Engine {
-  constructor(@inject(by('ILogger')) private logger: ILogger) {
-  }
-}
+container.resolve('ILogger') === container.resolve('ILogger'); // true
 
-const container = new Container(injector, { tags: ['root'] })
-  .add(Registration.fromClass(Engine));
+const scope = container.createScope();
+scope.resolve('ILogger') === scope.resolve('ILogger'); // true
+container.resolve('ILogger') !== scope.resolve('ILogger'); // true. NOTICE: because every provider is cloned for every child scope from parent one
 ```
 
-## Hooks
+### Tagged provider
+You need tagged provider when you want to resolve provider only from container with certain tags and their sub scopes.
+It doesn't make a clones in scopes with tags that are not in provider's tags. Usually it's used with `SingletonProvider`.
 
 ```typescript
-import {
-  Container,
-  IInjector,
-  ContainerHook,
-  Injector,
-  Registration,
-} from "ts-request-mediator";
-import { getHooks, hook } from "ts-constructor-injector";
+import { Provider, TaggedProvider, asSingleton, perTags } from "ts-ioc-container";
 
-@forKey('ILogger')
-class Logger {
-  @hook('OnConstruct')
-  initialize() {
-    console.log('initialized');
-  }
-
-  @hook('OnDispose')
-  dispose() {
-    console.log('disposed');
-  }
-}
+container.register('ILogger', Provider.fromClass(Logger).pipe((provider) => new TaggedProvider(provider, ['root'])));
+// OR
+container.register('ILogger', Provider.fromClass(Logger).pipe(perTags('root', 'parent')));
 
-const injector: IInjector = {
-  resolve<T>(container: IContainer, value: constructor<T>, ...deps: unknown[]): T {
-    const instance = resolve(container)(value, ...deps);
-    for (const h of getHooks(instance, 'OnConstruct')) {
-      // @ts-ignore
-      instance[h]();
-    }
-    return instance;
-  },
-}
+// with sigleton
+container.register('ILogger', Provider.fromClass(Logger).pipe(perTags('root', 'parent')).pipe(asSingleton()));
+container.resolve('ILogger') === container.resolve('ILogger'); // true
 
-const container = new Container(injector)
-  .add(Registration.fromClass(Logger));
-const logger = container.resolve<ILogger>('ILogger'); // initialized
-for (const instance of container.getInstances()) {
-  for (const h of getHooks(instance, 'OnDispose')) {
-    // @ts-ignore
-    instance[h]();
-  }
-}
+const scope = container.createScope();
+scope.resolve('ILogger') === scope.resolve('ILogger'); // true
+container.resolve('ILogger') === scope.resolve('ILogger'); // true
 ```
 
-## Scopes (child containers)
-
-- tags - you can add tag to scope and root container. And register provider per tag.
+### Args provider
+- You need args provider when you want to pass arguments to constructor on step when you compose container.
+- NOTICE: args from this provider has higher priority than args from `resolve` method.
 
 ```typescript
-import { composeDecorators } from "ts-constructor-injector";
-import { forKey, provider, Registration, asSingleton, perTags } from "ts-request-mediator";
+import { Provider, ArgsProvider, withArgs, withArgsFn } from "ts-ioc-container";
 
-@forKey('IEngine')
-@provider(perTags('root'), asSingleton())
 class Logger {
-}
-
-@forKey('IEngine')
-@provider(perTags('home'), asSingleton())
-class Engine {
-  constructor(@inject(by('ILogger')) private logger: ILogger) {
+  constructor(public type: string, public name: string) {
   }
 }
 
-const container = new Container(injector, { tags: ['root'] })
-  .add(Registration.fromClass(Logger))
-  .add(Registration.fromClass(Engine));
+container.register('ILogger', Provider.fromClass(Logger).pipe((provider) => new ArgsProvider(provider, () => ['FileLogger'])));
 
-const scope = container.createScope(['home', 'child']);
-const logger = scope.resolve('ILogger');
-scope.dispose();
+// OR
+container.register('ILogger', Provider.fromClass(Logger).pipe(withArgsFn(() => ['FileLogger'])));
+// OR
+container.register('ILogger', Provider.fromClass(Logger).pipe(withArgs('FileLogger')));
+
+container.resolve('ILogger', 'Main').type === 'FileLogger'; // true
+container.resolve('ILogger', 'Main').name === 'Main'; // true
 ```
 
 ## Container modules
 
+if you want to encapsulate some logic to enrich container you can use `IContainerModule`.
+
 ```typescript
-import { Registration } from "ts-request-mediator";
+import { Registration } from "ts-ioc-container";
 
 class Development implements IContainerModule {
   applyTo(container: IContainer): void {
@@ -334,14 +364,95 @@ const container = new Container(injector, { tags: ['root'] })
   .add(process.env.NODE_ENV === 'production' ? new Production() : new Development());
 ```
 
+## Registration module (Provider + DependencyKey)
+It's built-in module that encapsulates logic of registration provider by dependency key `forKey`. Just a sugar
+
+```typescript
+import { asSingleton, perTags, forKey, Registration, Provider } from "ts-ioc-container";
+
+@forKey('ILogger')
+@provider(asSingleton(), perTags('root'))
+class Logger {
+  info(message: string) {
+    console.log(message);
+  }
+}
+
+container.register(Registration.fromClass(Logger));
+
+// OR
+
+@provider(asSingleton(), perTags('root'))
+class Logger {
+  info(message: string) {
+    console.log(message);
+  }
+}
+
+container.register('ILogger', Provider.fromClass(Logger));
+```
+
+## Hooks
+You can mark methods of your classes as hooks. It's useful when you want to do something after construct of dispose classes.
+
+```typescript
+import {
+  Container,
+  IInjector,
+  ContainerHook,
+  Injector,
+  Registration,
+  getHooks,
+  hook,
+} from "ts-ioc-container";
+
+class MyInjector implements IInjector {
+  private injector = new ReflectionInjector();
+
+  resolve<T>(container: IContainer, value: constructor<T>, ...deps: unknown[]): T {
+    const instance = this.injector.resolve(container, value, ...deps);
+    for (const h of getHooks(instance, 'onConstruct')) {
+      // @ts-ignore
+      instance[h]();
+    }
+    return instance;
+  }
+}
+
+@forKey('ILogger')
+class Logger {
+  @hook('onConstruct')
+  initialize() {
+    console.log('initialized');
+  }
+
+  @hook('onDispose')
+  dispose() {
+    console.log('disposed');
+  }
+}
+
+const container = new Container(new MyInjector())
+  .add(Registration.fromClass(Logger));
+const logger = container.resolve<ILogger>('ILogger'); // initialized
+
+for (const instance of container.getInstances()) {
+  for (const h of getHooks(instance, 'onDispose')) {
+    // @ts-ignore
+    instance[h](); // disposed
+  }
+}
+```
+
 ## Mocking / Tests
+`AutoMockedContainer`. It will generate mocks for every dependency that you didn't define.
 
 ```typescript
 import {
   AutoMockedContainer,
   Container,
   DependencyKey,
-} from "ts-request-mediator";
+} from "ts-ioc-container";
 import { Mock } from "moq.ts";
 
 export class MoqContainer extends AutoMockedContainer {
@@ -351,10 +462,6 @@ export class MoqContainer extends AutoMockedContainer {
     return this.resolveMock<T>(key).object();
   }
 
-  dispose(): void {
-    this.mocks.clear();
-  }
-
   resolveMock<T>(key: DependencyKey): IMock<T> {
     if (!this.mocks.has(key)) {
       this.mocks.set(key, new Mock());

package/cjs/container/Container.d.ts

@@ -1,5 +1,5 @@
 import { DependencyKey, IContainer, IContainerModule, InjectionToken, Tag, Tagged } from './IContainer';
-import { IInjector } from '../IInjector';
+import { IInjector } from '../injector/IInjector';
 import { IProvider } from '../provider/IProvider';
 export declare class Container implements IContainer, Tagged {
     private readonly injector;

package/cjs/index.d.ts

@@ -1,9 +1,8 @@
-import { IContainer, InjectionToken } from './container/IContainer';
 export { IContainer, Resolvable, IContainerModule, isDependencyKey, DependencyKey, InjectionToken, Tag, } from './container/IContainer';
 export { constructor } from './utils';
 export { Container } from './container/Container';
 export { ResolveDependency, IProvider } from './provider/IProvider';
-export { IInjector } from './IInjector';
+export { IInjector } from './injector/IInjector';
 export { DependencyNotFoundError } from './container/DependencyNotFoundError';
 export { MethodNotImplementedError } from './container/MethodNotImplementedError';
 export { ContainerDisposedError } from './container/ContainerDisposedError';
@@ -14,4 +13,7 @@ export { perTags } from './provider/TaggedProvider';
 export { AutoMockedContainer } from './container/AutoMockedContainer';
 export { forKey, Registration } from './registration/Registration';
 export { DependencyMissingKeyError } from './registration/DependencyMissingKeyError';
-export declare const by: <T>(key: InjectionToken<T>, ...args: unknown[]) => (c: IContainer) => T;
+export { ReflectionInjector, inject, by } from './injector/ReflectionInjector';
+export { SimpleInjector } from './injector/SimpleInjector';
+export { ProxyInjector } from './injector/ProxyInjector';
+export { hook, getHooks } from './reflection';

package/cjs/index.js

@@ -1,31 +1,6 @@
 "use strict";
-var __read = (this && this.__read) || function (o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-};
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.by = exports.DependencyMissingKeyError = exports.Registration = exports.forKey = exports.AutoMockedContainer = exports.perTags = exports.asSingleton = exports.withArgs = exports.withArgsFn = exports.provider = exports.Provider = exports.ContainerDisposedError = exports.MethodNotImplementedError = exports.DependencyNotFoundError = exports.Container = exports.isDependencyKey = void 0;
+exports.getHooks = exports.hook = exports.ProxyInjector = exports.SimpleInjector = exports.by = exports.inject = exports.ReflectionInjector = exports.DependencyMissingKeyError = exports.Registration = exports.forKey = exports.AutoMockedContainer = exports.perTags = exports.asSingleton = exports.withArgs = exports.withArgsFn = exports.provider = exports.Provider = exports.ContainerDisposedError = exports.MethodNotImplementedError = exports.DependencyNotFoundError = exports.Container = exports.isDependencyKey = void 0;
 var IContainer_1 = require("./container/IContainer");
 Object.defineProperty(exports, "isDependencyKey", { enumerable: true, get: function () { return IContainer_1.isDependencyKey; } });
 var Container_1 = require("./container/Container");
@@ -53,14 +28,15 @@ Object.defineProperty(exports, "forKey", { enumerable: true, get: function () {
 Object.defineProperty(exports, "Registration", { enumerable: true, get: function () { return Registration_1.Registration; } });
 var DependencyMissingKeyError_1 = require("./registration/DependencyMissingKeyError");
 Object.defineProperty(exports, "DependencyMissingKeyError", { enumerable: true, get: function () { return DependencyMissingKeyError_1.DependencyMissingKeyError; } });
-var by = function (key) {
-    var args = [];
-    for (var _i = 1; _i < arguments.length; _i++) {
-        args[_i - 1] = arguments[_i];
-    }
-    return function (c) {
-        return c.resolve.apply(c, __spreadArray([key], __read(args), false));
-    };
-};
-exports.by = by;
+var ReflectionInjector_1 = require("./injector/ReflectionInjector");
+Object.defineProperty(exports, "ReflectionInjector", { enumerable: true, get: function () { return ReflectionInjector_1.ReflectionInjector; } });
+Object.defineProperty(exports, "inject", { enumerable: true, get: function () { return ReflectionInjector_1.inject; } });
+Object.defineProperty(exports, "by", { enumerable: true, get: function () { return ReflectionInjector_1.by; } });
+var SimpleInjector_1 = require("./injector/SimpleInjector");
+Object.defineProperty(exports, "SimpleInjector", { enumerable: true, get: function () { return SimpleInjector_1.SimpleInjector; } });
+var ProxyInjector_1 = require("./injector/ProxyInjector");
+Object.defineProperty(exports, "ProxyInjector", { enumerable: true, get: function () { return ProxyInjector_1.ProxyInjector; } });
+var reflection_1 = require("./reflection");
+Object.defineProperty(exports, "hook", { enumerable: true, get: function () { return reflection_1.hook; } });
+Object.defineProperty(exports, "getHooks", { enumerable: true, get: function () { return reflection_1.getHooks; } });
 //# sourceMappingURL=index.js.map

package/cjs/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../lib/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEA,qDAQgC;AAJ5B,6GAAA,eAAe,OAAA;AAMnB,mDAAkD;AAAzC,sGAAA,SAAS,OAAA;AAGlB,+EAA8E;AAArE,kIAAA,uBAAuB,OAAA;AAChC,mFAAkF;AAAzE,sIAAA,yBAAyB,OAAA;AAClC,6EAA4E;AAAnE,gIAAA,sBAAsB,OAAA;AAC/B,gDAAyD;AAAhD,oGAAA,QAAQ,OAAA;AAAE,oGAAA,QAAQ,OAAA;AAC3B,wDAAuE;AAAtD,0GAAA,UAAU,OAAA;AAAE,wGAAA,QAAQ,OAAA;AACrC,kEAA2D;AAAlD,gHAAA,WAAW,OAAA;AACpB,4DAAoD;AAA3C,yGAAA,OAAO,OAAA;AAChB,uEAAsE;AAA7D,0HAAA,mBAAmB,OAAA;AAC5B,4DAAmE;AAA1D,sGAAA,MAAM,OAAA;AAAE,4GAAA,YAAY,OAAA;AAC7B,sFAAqF;AAA5E,sIAAA,yBAAyB,OAAA;AAE3B,IAAM,EAAE,GACX,UAAI,GAAsB;IAAE,cAAkB;SAAlB,UAAkB,EAAlB,qBAAkB,EAAlB,IAAkB;QAAlB,6BAAkB;;IAC9C,OAAA,UAAC,CAAa;QACV,OAAA,CAAC,CAAC,OAAO,OAAT,CAAC,iBAAY,GAAG,UAAK,IAAI;IAAzB,CAA0B;AAD9B,CAC8B,CAAC;AAHtB,QAAA,EAAE,MAGoB"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../lib/index.ts"],"names":[],"mappings":";;;AAAA,qDAQgC;AAJ5B,6GAAA,eAAe,OAAA;AAMnB,mDAAkD;AAAzC,sGAAA,SAAS,OAAA;AAGlB,+EAA8E;AAArE,kIAAA,uBAAuB,OAAA;AAChC,mFAAkF;AAAzE,sIAAA,yBAAyB,OAAA;AAClC,6EAA4E;AAAnE,gIAAA,sBAAsB,OAAA;AAC/B,gDAAyD;AAAhD,oGAAA,QAAQ,OAAA;AAAE,oGAAA,QAAQ,OAAA;AAC3B,wDAAuE;AAAtD,0GAAA,UAAU,OAAA;AAAE,wGAAA,QAAQ,OAAA;AACrC,kEAA2D;AAAlD,gHAAA,WAAW,OAAA;AACpB,4DAAoD;AAA3C,yGAAA,OAAO,OAAA;AAChB,uEAAsE;AAA7D,0HAAA,mBAAmB,OAAA;AAC5B,4DAAmE;AAA1D,sGAAA,MAAM,OAAA;AAAE,4GAAA,YAAY,OAAA;AAC7B,sFAAqF;AAA5E,sIAAA,yBAAyB,OAAA;AAClC,oEAA+E;AAAtE,wHAAA,kBAAkB,OAAA;AAAE,4GAAA,MAAM,OAAA;AAAE,wGAAA,EAAE,OAAA;AACvC,4DAA2D;AAAlD,gHAAA,cAAc,OAAA;AACvB,0DAAyD;AAAhD,8GAAA,aAAa,OAAA;AACtB,2CAA8C;AAArC,kGAAA,IAAI,OAAA;AAAE,sGAAA,QAAQ,OAAA"}