atomic-di 2.0.0 → 2.0.2

package/README.md

@@ -233,22 +233,13 @@ IoC containers implement this by defining copies of a container in different par
 ### Creating a scope
 
 There are two ways to create a scope:
-- Create a map with the correct type manually.
-```ts
-const scope = new Map<Resolver<any>, any>()
-```
-- Use `createScope` function.
+- By calling `createScope` function.
 ```ts
 const scope = createScope()
 ```
-
-It is important to note that a scope must be created **once** during an entire lifecycle of a program.
+- By creating a `Map` with the correct type manually.
 ```ts
-const requestScope = createScope()
-
-app.use(() => {
-    // use the scope here
-})
+const scope = new Map<Resolver<any>, any>()
 ```
 
 ### Resolving with a scope

package/dist/index.d.mts

@@ -1,50 +1,75 @@
+type PromiseAwarePartial<T> = T extends Promise<infer U> ? Promise<Partial<U>> : Partial<T>;
+type Mock<T> = {
+    isPartial: false;
+    resolver: Resolver<T>;
+} | {
+    isPartial: true;
+    resolver: Resolver<PromiseAwarePartial<T>>;
+};
 /**
- * A `Map` of providers to providers of the same type
- * which is then passed to a provider call in a resolution context object
- * in order to replace providers with their mocks.
+ * Immutable map that registers and provides mocks.
+ * Is passed in a resolution context and used by resolvers
+ * to replace or partially replace themselves with a mock if one is defined.
  */
-type MockMap = Omit<Map<Resolver<any>, Resolver<any>>, "set" | "get"> & {
+type MockMap = {
+    /**
+     * Registers a mock for a resolver,
+     * creating a new `MockMap` with this registration.
+     *
+     * @param original - The original resolver.
+     * @param mock - The mock resolver.
+     */
+    mock<T>(original: Resolver<T>, mock: Resolver<T>): MockMap;
     /**
-     * Sets a mock for a provider.
+     * Registers a partial mock for a resolver,
+     * creating a new `MockMap` with this registration.
+     * In this case, the mock resolver's resolution object will be
+     * merged with the original resolver's resolution object,
+     * overwriting certain fields.
      *
-     * @param provider - The original provider.
-     * @param mock - The mock provider.
+     * @param original - The original resolver.
+     * @param mock - The mock resolver.
      */
-    set<T>(provider: Resolver<T>, mock: Resolver<T>): MockMap;
+    mockPartially<T extends object>(original: Resolver<T>, mock: Resolver<PromiseAwarePartial<T>>): MockMap;
     /**
-     * Retrieves a mock of a provider. Returns undefined if there's none.
+     * Returns a mock of a resolver
+     * or `undefined` if one is not registered.
      *
-     * @param provider - The provider.
+     * @param original - The original resolver.
      */
-    get<T>(provider: Resolver<T>): Resolver<T> | undefined;
+    get<T>(original: Resolver<T>): Mock<T> | undefined;
 };
 /**
- * Creates a `Map` of providers to providers of the same type
- * which is then passed to a provider call in a resolution context object
- * in order to replace providers with their mocks.
+ * Creates a mock map, an immutable map that registers and provides mocks.
+ * Is passed in a resolution context and used by resolvers
+ * to replace or partially replace themselves with a mock if one is defined.
  *
  * @example
  * ```ts
  * const mocks = createMockMap()
- *     .set(getConfig, getTestConfig)
+ *     .mock(getDependency, getDependencyMock)
+ *     .mockPartially(
+ *         getOtherDepedency,
+ *         transient(() => ({ someField: "mock" }))
+ *     )
  *
- * getThing({ mocks })
+ * const entityWithMocks = getEntity({ mocks })
  * ```
  *
- * @returns The map instance.
+ * @returns The mock map.
  */
 declare const createMockMap: () => MockMap;
 
 /**
- * A `Map` of providers to their instances
- * that is then passed to a provider call in a resolution context object
- * to resolve instances of scoped providers within it.
+ * A `Map` of resolvers to their resolutions.
+ * Is passed in a resolution context and used by scoped resolvers
+ * to retrieve or save resolution within it.
  */
 type Scope = Map<Resolver<any>, any>;
 /**
- * Creates a `Map` of providers to their instances
- * that is then passed to a provider call in a resolution context object
- * to resolve instances of scoped providers within it.
+ * Creates a `Map` of providers to their instances.
+ * Is passed in a resolution context and used by scoped resolvers
+ * to retrieve or save resolution within it.
  *
  * @example
  * ```ts
@@ -52,97 +77,95 @@ type Scope = Map<Resolver<any>, any>;
  *
  * app.use(() => {
  *     const db = getDb({ scope: requestScope })
- *     // ...
  * })
  * ```
  *
- * @returns The map instance.
+ * @returns The map.
  */
 declare const createScope: () => Scope;
 
 /**
- * A function that returns a value of a particular type
- * with a resolution context being passed to it.
+ * A function that takes a resolution context
+ * and returns a value of some type.
  */
-type Resolver<T> = (context?: ResolutionContext) => T;
+type ResolverFn<T> = (context?: ResolutionContext) => T;
 /**
- * A function that resolves an instance or a `Promise` of a particular type
- * based on a resolution context passed to it.
+ * A function that returns a value of some type
+ * based on a resolution context.
  */
-type Provider<T> = Resolver<T> & {
-    __brand: "provider";
-};
+type Resolver<T> = ResolverFn<T>;
 /**
- * A context used by providers to resolve instances
- * based on current scope and mocks.
+ * A context used by resolvers that defines the behaviour of the resolver
+ * with the passed mocks and scope.
  */
 type ResolutionContext = {
     scope?: Scope;
     mocks?: MockMap;
 };
 /**
- * Creates a transient provider that will resolve a new instance on each call.
+ * Creates a resolver that creates a new resolution on each call.
  *
  * @example
  * ```ts
- * const getThing = transient(() => createThing())
- * getThing() !== getThing()
+ * const getEntity = transient(() => createEntity())
+ * getEntity() !== getEntity()
  * ```
  *
  * @param resolver
- * A function that returns a value of a particular type
- * with a resolution context being passed to it.
+ * A function that takes a resolution context
+ * and returns a value of some type.
  *
- * @returns The transient provider.
+ * @returns The transient resolver.
  */
-declare const transient: <T>(resolver: Resolver<T>) => Provider<T>;
+declare const transient: <T>(fn: ResolverFn<T>) => Resolver<T>;
 /**
- * Creates a singleton provider that will resolve an instance once
- * and return it on every call.
+ * Creates a resolver that creates
+ * a resolution once and return it on each call.
  *
  * @example
  * ```ts
- * const getThing = singleton(() => createThing())
- * getThing() === getThing()
+ * const getEntity = singleton(() => createEntity())
+ * getEntity() === getEntity()
  * ```
  *
- * @param resolver
- * A function that returns a value of a particular type
- * with a resolution context being passed to it.
+ * @param fn
+ * A function that takes a resolution context
+ * and returns a value of some type.
  *
- * @returns The singleton provider.
+ * @returns The singleton resolver.
  */
-declare const singleton: <T>(resolver: Resolver<T>) => Provider<T>;
+declare const singleton: <T>(fn: ResolverFn<T>) => Resolver<T>;
 /**
- * Creates a scoped provider that will take its resolution from a passed scope
- * or create a new one and save it if there is none.
- * If no scope is passed, it will act as a singleton.
+ * Creates a resolver that takes its resolution
+ * from a scope or create a new one and save it if there is none.
+ * If no scope was passed in a resolution context,
+ * it will act as a singleton.
  *
  * @example
  * ```ts
- * const getThing = scoped(() => createThing())
- * getThing() === getThing()
+ * const getEntity = scoped(() => createEntity())
+ * getEntity() === getEntity()
  * ```
  *
  * @example
  * ```ts
- * const getThing = scoped(() => createThing())
+ * const getEntity = scoped(() => createEntity())
  * const scope = createScope()
- * getThing({ scope }) === getThing({ scope }) !== getThing()
+ * getEntity({ scope }) === getEntity({ scope }) !== getEntity()
  * ```
  *
- * @param resolver
- * A function that returns a value of a particular type
- * with a resolution context being passed to it.
+ * @param fn
+ * A function that takes a resolution context
+ * and returns a value of some type.
  *
- * @returns The scoped provider.
+ * @returns The scoped resolver.
  */
-declare const scoped: <T>(resolver: Resolver<T>) => Provider<T>;
+declare const scoped: <T>(fn: ResolverFn<T>) => Resolver<T>;
 
-type ProviderList = Provider<any>[];
-type ProviderRecord = Record<string, Provider<any>>;
-type InferProviderCollectionResolutions<Providers extends ProviderList | ProviderRecord> = {
-    [K in keyof Providers]: Providers[K] extends Provider<infer T> ? T : never;
+type ResolverList = Resolver<any>[];
+type ResolverRecord = Record<string, Resolver<any>>;
+type InferResolverCollectionResolutions<Resolvers extends ResolverList | ResolverRecord> = {
+    [K in keyof Resolvers]: Resolvers[K] extends Resolver<infer T> ? T : never;
 };
 /**
  * Awaits all promises and wraps the collection in a promise
@@ -153,12 +176,12 @@ type AwaitValuesInCollection<T extends any[] | Record<any, any>> = Promise<any>
     [I in keyof T]: T[I] extends Promise<infer T> ? T : T[I];
 }> : T;
 /**
- * Calls every provider in a list with a provided resolution context
+ * Calls every resolver in a list with a provided resolution context
  * and returns a list of resolutions. Returns a `Promise` of a list
  * of awaited resolutions if there's at least one `Promise` in the resolutions.
  *
  * @example
- * Only sync providers:
+ * Only sync resolvers:
  * ```ts
  * const getA = scoped(() => createA())
  * const getB = scoped(() => createB())
@@ -178,7 +201,7 @@ type AwaitValuesInCollection<T extends any[] | Record<any, any>> = Promise<any>
  * ```
  *
  * @example
- * Some provider is async:
+ * Some resolver is async:
  * ```ts
  * const getA = scoped(() => createA())
  * const getB = scoped(async () => await createB())
@@ -197,20 +220,20 @@ type AwaitValuesInCollection<T extends any[] | Record<any, any>> = Promise<any>
  * ]
  * ```
  *
- * @param providers - The list of providers.
+ * @param resolvers - The list of resolvers.
  * @param context - The resolution context.
  *
  * @returns The list of resolutions.
  */
-declare const resolveList: <const Providers extends ProviderList>(providers: Providers, context?: ResolutionContext) => AwaitValuesInCollection<InferProviderCollectionResolutions<Providers>>;
+declare const resolveList: <const Resolvers extends ResolverList>(resolvers: Resolvers, context?: ResolutionContext) => AwaitValuesInCollection<InferResolverCollectionResolutions<Resolvers>>;
 /**
- * Calls every provider in a map with a provided resolution context
+ * Calls every resolver in a map with a provided resolution context
  * and returns a map with identical keys but with resolutions in values instead.
  * Returns a `Promise` of a map of awaited resolutions if there's at least one
  * `Promise` in the resolutions.
  *
  * @example
- * Only sync providers:
+ * Only sync resolvers:
  * ```ts
  * const getA = scoped(() => createA())
  * const getB = scoped(() => createB())
@@ -230,7 +253,7 @@ declare const resolveList: <const Providers extends ProviderList>(providers: Pro
  * ```
  *
  * @example
- * Some provider is async:
+ * Some resolver is async:
  * ```ts
  * const getA = scoped(() => createA())
  * const getB = scoped(async () => await createB())
@@ -249,11 +272,11 @@ declare const resolveList: <const Providers extends ProviderList>(providers: Pro
  * }
  * ```
  *
- * @param providers - The map of providers.
+ * @param resolvers - The map of resolvers.
  * @param context - The resolution context.
  *
  * @returns The map of resolutions.
  */
-declare const resolveMap: <const Providers extends ProviderRecord>(providers: Providers, context?: ResolutionContext) => AwaitValuesInCollection<InferProviderCollectionResolutions<Providers>>;
+declare const resolveMap: <const Resolvers extends ResolverRecord>(resolvers: Resolvers, context?: ResolutionContext) => AwaitValuesInCollection<InferResolverCollectionResolutions<Resolvers>>;
 
-export { type MockMap, type Provider, type ResolutionContext, type Resolver, type Scope, createMockMap, createScope, resolveList, resolveMap, scoped, singleton, transient };
+export { type MockMap, type ResolutionContext, type Resolver, type ResolverFn, type Scope, createMockMap, createScope, resolveList, resolveMap, scoped, singleton, transient };

package/dist/index.d.ts

@@ -1,50 +1,75 @@
+type PromiseAwarePartial<T> = T extends Promise<infer U> ? Promise<Partial<U>> : Partial<T>;
+type Mock<T> = {
+    isPartial: false;
+    resolver: Resolver<T>;
+} | {
+    isPartial: true;
+    resolver: Resolver<PromiseAwarePartial<T>>;
+};
 /**
- * A `Map` of providers to providers of the same type
- * which is then passed to a provider call in a resolution context object
- * in order to replace providers with their mocks.
+ * Immutable map that registers and provides mocks.
+ * Is passed in a resolution context and used by resolvers
+ * to replace or partially replace themselves with a mock if one is defined.
  */
-type MockMap = Omit<Map<Resolver<any>, Resolver<any>>, "set" | "get"> & {
+type MockMap = {
+    /**
+     * Registers a mock for a resolver,
+     * creating a new `MockMap` with this registration.
+     *
+     * @param original - The original resolver.
+     * @param mock - The mock resolver.
+     */
+    mock<T>(original: Resolver<T>, mock: Resolver<T>): MockMap;
     /**
-     * Sets a mock for a provider.
+     * Registers a partial mock for a resolver,
+     * creating a new `MockMap` with this registration.
+     * In this case, the mock resolver's resolution object will be
+     * merged with the original resolver's resolution object,
+     * overwriting certain fields.
      *
-     * @param provider - The original provider.
-     * @param mock - The mock provider.
+     * @param original - The original resolver.
+     * @param mock - The mock resolver.
      */
-    set<T>(provider: Resolver<T>, mock: Resolver<T>): MockMap;
+    mockPartially<T extends object>(original: Resolver<T>, mock: Resolver<PromiseAwarePartial<T>>): MockMap;
     /**
-     * Retrieves a mock of a provider. Returns undefined if there's none.
+     * Returns a mock of a resolver
+     * or `undefined` if one is not registered.
      *
-     * @param provider - The provider.
+     * @param original - The original resolver.
      */
-    get<T>(provider: Resolver<T>): Resolver<T> | undefined;
+    get<T>(original: Resolver<T>): Mock<T> | undefined;
 };
 /**
- * Creates a `Map` of providers to providers of the same type
- * which is then passed to a provider call in a resolution context object
- * in order to replace providers with their mocks.
+ * Creates a mock map, an immutable map that registers and provides mocks.
+ * Is passed in a resolution context and used by resolvers
+ * to replace or partially replace themselves with a mock if one is defined.
  *
  * @example
  * ```ts
  * const mocks = createMockMap()
- *     .set(getConfig, getTestConfig)
+ *     .mock(getDependency, getDependencyMock)
+ *     .mockPartially(
+ *         getOtherDepedency,
+ *         transient(() => ({ someField: "mock" }))
+ *     )
  *
- * getThing({ mocks })
+ * const entityWithMocks = getEntity({ mocks })
  * ```
  *
- * @returns The map instance.
+ * @returns The mock map.
  */
 declare const createMockMap: () => MockMap;
 
 /**
- * A `Map` of providers to their instances
- * that is then passed to a provider call in a resolution context object
- * to resolve instances of scoped providers within it.
+ * A `Map` of resolvers to their resolutions.
+ * Is passed in a resolution context and used by scoped resolvers
+ * to retrieve or save resolution within it.
  */
 type Scope = Map<Resolver<any>, any>;
 /**
- * Creates a `Map` of providers to their instances
- * that is then passed to a provider call in a resolution context object
- * to resolve instances of scoped providers within it.
+ * Creates a `Map` of providers to their instances.
+ * Is passed in a resolution context and used by scoped resolvers
+ * to retrieve or save resolution within it.
  *
  * @example
  * ```ts
@@ -52,97 +77,95 @@ type Scope = Map<Resolver<any>, any>;
  *
  * app.use(() => {
  *     const db = getDb({ scope: requestScope })
- *     // ...
  * })
  * ```
  *
- * @returns The map instance.
+ * @returns The map.
  */
 declare const createScope: () => Scope;
 
 /**
- * A function that returns a value of a particular type
- * with a resolution context being passed to it.
+ * A function that takes a resolution context
+ * and returns a value of some type.
  */
-type Resolver<T> = (context?: ResolutionContext) => T;
+type ResolverFn<T> = (context?: ResolutionContext) => T;
 /**
- * A function that resolves an instance or a `Promise` of a particular type
- * based on a resolution context passed to it.
+ * A function that returns a value of some type
+ * based on a resolution context.
  */
-type Provider<T> = Resolver<T> & {
-    __brand: "provider";
-};
+type Resolver<T> = ResolverFn<T>;
 /**
- * A context used by providers to resolve instances
- * based on current scope and mocks.
+ * A context used by resolvers that defines the behaviour of the resolver
+ * with the passed mocks and scope.
  */
 type ResolutionContext = {
     scope?: Scope;
     mocks?: MockMap;
 };
 /**
- * Creates a transient provider that will resolve a new instance on each call.
+ * Creates a resolver that creates a new resolution on each call.
  *
  * @example
  * ```ts
- * const getThing = transient(() => createThing())
- * getThing() !== getThing()
+ * const getEntity = transient(() => createEntity())
+ * getEntity() !== getEntity()
  * ```
  *
  * @param resolver
- * A function that returns a value of a particular type
- * with a resolution context being passed to it.
+ * A function that takes a resolution context
+ * and returns a value of some type.
  *
- * @returns The transient provider.
+ * @returns The transient resolver.
  */
-declare const transient: <T>(resolver: Resolver<T>) => Provider<T>;
+declare const transient: <T>(fn: ResolverFn<T>) => Resolver<T>;
 /**
- * Creates a singleton provider that will resolve an instance once
- * and return it on every call.
+ * Creates a resolver that creates
+ * a resolution once and return it on each call.
  *
  * @example
  * ```ts
- * const getThing = singleton(() => createThing())
- * getThing() === getThing()
+ * const getEntity = singleton(() => createEntity())
+ * getEntity() === getEntity()
  * ```
  *
- * @param resolver
- * A function that returns a value of a particular type
- * with a resolution context being passed to it.
+ * @param fn
+ * A function that takes a resolution context
+ * and returns a value of some type.
  *
- * @returns The singleton provider.
+ * @returns The singleton resolver.
  */
-declare const singleton: <T>(resolver: Resolver<T>) => Provider<T>;
+declare const singleton: <T>(fn: ResolverFn<T>) => Resolver<T>;
 /**
- * Creates a scoped provider that will take its resolution from a passed scope
- * or create a new one and save it if there is none.
- * If no scope is passed, it will act as a singleton.
+ * Creates a resolver that takes its resolution
+ * from a scope or create a new one and save it if there is none.
+ * If no scope was passed in a resolution context,
+ * it will act as a singleton.
  *
  * @example
  * ```ts
- * const getThing = scoped(() => createThing())
- * getThing() === getThing()
+ * const getEntity = scoped(() => createEntity())
+ * getEntity() === getEntity()
  * ```
  *
  * @example
  * ```ts
- * const getThing = scoped(() => createThing())
+ * const getEntity = scoped(() => createEntity())
  * const scope = createScope()
- * getThing({ scope }) === getThing({ scope }) !== getThing()
+ * getEntity({ scope }) === getEntity({ scope }) !== getEntity()
  * ```
  *
- * @param resolver
- * A function that returns a value of a particular type
- * with a resolution context being passed to it.
+ * @param fn
+ * A function that takes a resolution context
+ * and returns a value of some type.
  *
- * @returns The scoped provider.
+ * @returns The scoped resolver.
  */
-declare const scoped: <T>(resolver: Resolver<T>) => Provider<T>;
+declare const scoped: <T>(fn: ResolverFn<T>) => Resolver<T>;
 
-type ProviderList = Provider<any>[];
-type ProviderRecord = Record<string, Provider<any>>;
-type InferProviderCollectionResolutions<Providers extends ProviderList | ProviderRecord> = {
-    [K in keyof Providers]: Providers[K] extends Provider<infer T> ? T : never;
+type ResolverList = Resolver<any>[];
+type ResolverRecord = Record<string, Resolver<any>>;
+type InferResolverCollectionResolutions<Resolvers extends ResolverList | ResolverRecord> = {
+    [K in keyof Resolvers]: Resolvers[K] extends Resolver<infer T> ? T : never;
 };
 /**
  * Awaits all promises and wraps the collection in a promise
@@ -153,12 +176,12 @@ type AwaitValuesInCollection<T extends any[] | Record<any, any>> = Promise<any>
     [I in keyof T]: T[I] extends Promise<infer T> ? T : T[I];
 }> : T;
 /**
- * Calls every provider in a list with a provided resolution context
+ * Calls every resolver in a list with a provided resolution context
  * and returns a list of resolutions. Returns a `Promise` of a list
  * of awaited resolutions if there's at least one `Promise` in the resolutions.
  *
  * @example
- * Only sync providers:
+ * Only sync resolvers:
  * ```ts
  * const getA = scoped(() => createA())
  * const getB = scoped(() => createB())
@@ -178,7 +201,7 @@ type AwaitValuesInCollection<T extends any[] | Record<any, any>> = Promise<any>
  * ```
  *
  * @example
- * Some provider is async:
+ * Some resolver is async:
  * ```ts
  * const getA = scoped(() => createA())
  * const getB = scoped(async () => await createB())
@@ -197,20 +220,20 @@ type AwaitValuesInCollection<T extends any[] | Record<any, any>> = Promise<any>
  * ]
  * ```
  *
- * @param providers - The list of providers.
+ * @param resolvers - The list of resolvers.
  * @param context - The resolution context.
  *
  * @returns The list of resolutions.
  */
-declare const resolveList: <const Providers extends ProviderList>(providers: Providers, context?: ResolutionContext) => AwaitValuesInCollection<InferProviderCollectionResolutions<Providers>>;
+declare const resolveList: <const Resolvers extends ResolverList>(resolvers: Resolvers, context?: ResolutionContext) => AwaitValuesInCollection<InferResolverCollectionResolutions<Resolvers>>;
 /**
- * Calls every provider in a map with a provided resolution context
+ * Calls every resolver in a map with a provided resolution context
  * and returns a map with identical keys but with resolutions in values instead.
  * Returns a `Promise` of a map of awaited resolutions if there's at least one
  * `Promise` in the resolutions.
  *
  * @example
- * Only sync providers:
+ * Only sync resolvers:
  * ```ts
  * const getA = scoped(() => createA())
  * const getB = scoped(() => createB())
@@ -230,7 +253,7 @@ declare const resolveList: <const Providers extends ProviderList>(providers: Pro
  * ```
  *
  * @example
- * Some provider is async:
+ * Some resolver is async:
  * ```ts
  * const getA = scoped(() => createA())
  * const getB = scoped(async () => await createB())
@@ -249,11 +272,11 @@ declare const resolveList: <const Providers extends ProviderList>(providers: Pro
  * }
  * ```
  *
- * @param providers - The map of providers.
+ * @param resolvers - The map of resolvers.
  * @param context - The resolution context.
  *
  * @returns The map of resolutions.
  */
-declare const resolveMap: <const Providers extends ProviderRecord>(providers: Providers, context?: ResolutionContext) => AwaitValuesInCollection<InferProviderCollectionResolutions<Providers>>;
+declare const resolveMap: <const Resolvers extends ResolverRecord>(resolvers: Resolvers, context?: ResolutionContext) => AwaitValuesInCollection<InferResolverCollectionResolutions<Resolvers>>;
 
-export { type MockMap, type Provider, type ResolutionContext, type Resolver, type Scope, createMockMap, createScope, resolveList, resolveMap, scoped, singleton, transient };
+export { type MockMap, type ResolutionContext, type Resolver, type ResolverFn, type Scope, createMockMap, createScope, resolveList, resolveMap, scoped, singleton, transient };

package/dist/index.js

@@ -29,33 +29,40 @@ __export(src_exports, {
 });
 module.exports = __toCommonJS(src_exports);
 
-// src/provider.ts
-var createProvider = (resolver) => {
+// src/resolver.ts
+var mockable = (fn) => {
   const instance = (context) => {
     var _a;
-    const maybeMock = (_a = context == null ? void 0 : context.mocks) == null ? void 0 : _a.get(instance);
-    if (maybeMock) return maybeMock(context);
-    return resolver(context);
+    const mock = (_a = context == null ? void 0 : context.mocks) == null ? void 0 : _a.get(instance);
+    if (!mock) return fn(context);
+    if (!mock.isPartial) return mock.resolver(context);
+    const resolution = fn(context);
+    const mockResolution = mock.resolver(context);
+    if (resolution instanceof Promise && mockResolution instanceof Promise)
+      return Promise.all([resolution, mockResolution]).then(
+        ([a, b]) => Object.assign(a, b)
+      );
+    return Object.assign(resolution, mockResolution);
   };
-  return Object.assign(instance, { __brand: "provider" });
+  return instance;
 };
-var transient = createProvider;
-var singleton = (resolver) => {
+var transient = (fn) => mockable(fn);
+var singleton = (fn) => {
   let resolved = false;
   let resolution;
-  const instance = createProvider((context) => {
+  const instance = mockable((context) => {
     if (resolved) return resolution;
-    resolution = resolver(context);
+    resolution = fn(context);
     resolved = true;
     return resolution;
   });
   return instance;
 };
-var scoped = (resolver) => {
-  const singletonFallback = singleton(resolver);
-  const instance = createProvider((context) => {
+var scoped = (fn) => {
+  const singletonFallback = singleton(fn);
+  const instance = mockable((context) => {
     if (!(context == null ? void 0 : context.scope)) return singletonFallback(context);
-    const resolution = context.scope.has(instance) ? context.scope.get(instance) : resolver(context);
+    const resolution = context.scope.has(instance) ? context.scope.get(instance) : fn(context);
     context.scope.set(instance, resolution);
     return resolution;
   });
@@ -66,19 +73,43 @@ var scoped = (resolver) => {
 var createScope = () => /* @__PURE__ */ new Map();
 
 // src/mock-map.ts
-var createMockMap = () => /* @__PURE__ */ new Map();
+var createMockMapWithEntries = (entries = []) => {
+  const set = (key, value) => createMockMapWithEntries([
+    ...entries.filter((entry) => entry[0] !== key),
+    [key, value]
+  ]);
+  return {
+    mock(original, mock) {
+      return set(original, {
+        isPartial: false,
+        resolver: mock
+      });
+    },
+    mockPartially(original, mock) {
+      return set(original, {
+        isPartial: true,
+        resolver: mock
+      });
+    },
+    get(original) {
+      var _a;
+      return (_a = entries.find((entry) => entry[0] === original)) == null ? void 0 : _a[1];
+    }
+  };
+};
+var createMockMap = () => createMockMapWithEntries();
 
 // src/collection-resolution.ts
-var resolveList = (providers, context) => {
-  const resolutions = providers.map((provider) => provider(context));
+var resolveList = (resolvers, context) => {
+  const resolutions = resolvers.map((resolver) => resolver(context));
   const hasPromises = resolutions.some(
     (resolution) => resolution instanceof Promise
   );
   return hasPromises ? Promise.all(resolutions) : resolutions;
 };
-var resolveMap = (providers, context) => {
-  const resolutionMapEntries = Object.entries(providers).map(
-    ([key, provider]) => [key, provider(context)]
+var resolveMap = (resolvers, context) => {
+  const resolutionMapEntries = Object.entries(resolvers).map(
+    ([key, resolver]) => [key, resolver(context)]
   );
   const hasPromises = resolutionMapEntries.some(
     ([, resolution]) => resolution instanceof Promise

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/index.ts","../src/provider.ts","../src/scope.ts","../src/mock-map.ts","../src/collection-resolution.ts"],"sourcesContent":["export * from \"./provider\";\nexport * from \"./scope\";\nexport * from \"./mock-map\";\nexport * from \"./collection-resolution\";\n","import { MockMap } from \"./mock-map\";\nimport { Scope } from \"./scope\";\n\n/**\n * A function that returns a value of a particular type\n * with a resolution context being passed to it.\n */\nexport type Resolver<T> = (context?: ResolutionContext) => T;\n\n/**\n * A function that resolves an instance or a `Promise` of a particular type\n * based on a resolution context passed to it.\n */\nexport type Provider<T> = Resolver<T> & { __brand: \"provider\" };\n\n/**\n * A context used by providers to resolve instances\n * based on current scope and mocks.\n */\nexport type ResolutionContext = {\n    scope?: Scope;\n    mocks?: MockMap;\n};\n\n/**\n * Creating a nominal type value and introducing common functionality.\n */\nconst createProvider = <T>(resolver: Resolver<T>): Provider<T> => {\n    const instance: Resolver<T> = (context) => {\n        const maybeMock = context?.mocks?.get(instance);\n        if (maybeMock) return maybeMock(context);\n\n        return resolver(context);\n    };\n\n    return Object.assign(instance, { __brand: \"provider\" as const });\n};\n\n/**\n * Creates a transient provider that will resolve a new instance on each call.\n *\n * @example\n * ```ts\n * const getThing = transient(() => createThing())\n * getThing() !== getThing()\n * ```\n *\n * @param resolver\n * A function that returns a value of a particular type\n * with a resolution context being passed to it.\n *\n * @returns The transient provider.\n */\nexport const transient = createProvider;\n\n/**\n * Creates a singleton provider that will resolve an instance once\n * and return it on every call.\n *\n * @example\n * ```ts\n * const getThing = singleton(() => createThing())\n * getThing() === getThing()\n * ```\n *\n * @param resolver\n * A function that returns a value of a particular type\n * with a resolution context being passed to it.\n *\n * @returns The singleton provider.\n */\nexport const singleton = <T>(resolver: Resolver<T>): Provider<T> => {\n    let resolved = false;\n    let resolution: T | undefined;\n\n    const instance = createProvider((context) => {\n        if (resolved) return resolution!;\n\n        resolution = resolver(context);\n        resolved = true;\n\n        return resolution;\n    });\n\n    return instance;\n};\n\n/**\n * Creates a scoped provider that will take its resolution from a passed scope\n * or create a new one and save it if there is none.\n * If no scope is passed, it will act as a singleton.\n *\n * @example\n * ```ts\n * const getThing = scoped(() => createThing())\n * getThing() === getThing()\n * ```\n *\n * @example\n * ```ts\n * const getThing = scoped(() => createThing())\n * const scope = createScope()\n * getThing({ scope }) === getThing({ scope }) !== getThing()\n * ```\n *\n * @param resolver\n * A function that returns a value of a particular type\n * with a resolution context being passed to it.\n *\n * @returns The scoped provider.\n */\nexport const scoped = <T>(resolver: Resolver<T>): Provider<T> => {\n    const singletonFallback = singleton(resolver);\n\n    const instance = createProvider((context) => {\n        if (!context?.scope) return singletonFallback(context);\n\n        const resolution = context.scope.has(instance)\n            ? context.scope.get(instance)\n            : resolver(context);\n        context.scope.set(instance, resolution);\n\n        return resolution;\n    });\n\n    return instance;\n};\n","import { Resolver } from \"./provider\";\n\n/**\n * A `Map` of providers to their instances\n * that is then passed to a provider call in a resolution context object\n * to resolve instances of scoped providers within it.\n */\nexport type Scope = Map<Resolver<any>, any>;\n\n/**\n * Creates a `Map` of providers to their instances\n * that is then passed to a provider call in a resolution context object\n * to resolve instances of scoped providers within it.\n *\n * @example\n * ```ts\n * const requestScope = createScope()\n *\n * app.use(() => {\n *     const db = getDb({ scope: requestScope })\n *     // ...\n * })\n * ```\n *\n * @returns The map instance.\n */\nexport const createScope = (): Scope => new Map();\n","import { Resolver } from \"./provider\";\n\n/**\n * A `Map` of providers to providers of the same type\n * which is then passed to a provider call in a resolution context object\n * in order to replace providers with their mocks.\n */\nexport type MockMap = Omit<Map<Resolver<any>, Resolver<any>>, \"set\" | \"get\"> & {\n    /**\n     * Sets a mock for a provider.\n     *\n     * @param provider - The original provider.\n     * @param mock - The mock provider.\n     */\n    set<T>(provider: Resolver<T>, mock: Resolver<T>): MockMap;\n    /**\n     * Retrieves a mock of a provider. Returns undefined if there's none.\n     *\n     * @param provider - The provider.\n     */\n    get<T>(provider: Resolver<T>): Resolver<T> | undefined;\n};\n\n/**\n * Creates a `Map` of providers to providers of the same type\n * which is then passed to a provider call in a resolution context object\n * in order to replace providers with their mocks.\n *\n * @example\n * ```ts\n * const mocks = createMockMap()\n *     .set(getConfig, getTestConfig)\n *\n * getThing({ mocks })\n * ```\n *\n * @returns The map instance.\n */\nexport const createMockMap = (): MockMap => new Map();\n","import { Provider, ResolutionContext } from \"./provider\";\n\ntype ProviderList = Provider<any>[];\ntype ProviderRecord = Record<string, Provider<any>>;\n\ntype InferProviderCollectionResolutions<\n    Providers extends ProviderList | ProviderRecord,\n> = {\n    [K in keyof Providers]: Providers[K] extends Provider<infer T> ? T : never;\n};\n\n/**\n * Awaits all promises and wraps the collection in a promise\n * if there'ss at least one `Promise` in the collection,\n * otherwise returns an untouched type.\n */\ntype AwaitValuesInCollection<T extends any[] | Record<any, any>> =\n    Promise<any> extends T[keyof T]\n        ? Promise<{\n              [I in keyof T]: T[I] extends Promise<infer T> ? T : T[I];\n          }>\n        : T;\n\n/**\n * Calls every provider in a list with a provided resolution context\n * and returns a list of resolutions. Returns a `Promise` of a list\n * of awaited resolutions if there's at least one `Promise` in the resolutions.\n *\n * @example\n * Only sync providers:\n * ```ts\n * const getA = scoped(() => createA())\n * const getB = scoped(() => createB())\n * const getC = scoped(() => createC())\n *\n * const scope = createScope()\n * const resolutions = resolveList(\n *     [getA, getB, getC],\n *     { scope }\n * )\n *\n * resolutions == [\n *     getA({ scope }),\n *     getB({ scope }),\n *     getC({ scope })\n * ]\n * ```\n *\n * @example\n * Some provider is async:\n * ```ts\n * const getA = scoped(() => createA())\n * const getB = scoped(async () => await createB())\n * const getC = scoped(() => createC())\n *\n * const scope = createScope()\n * const resolutions = resolveList(\n *     [getA, getB, getC],\n *     { scope }\n * )\n *\n * resolutions == [\n *     getA({ scope }),\n *     await getB({ scope }),\n *     getC({ scope })\n * ]\n * ```\n *\n * @param providers - The list of providers.\n * @param context - The resolution context.\n *\n * @returns The list of resolutions.\n */\nexport const resolveList = <const Providers extends ProviderList>(\n    providers: Providers,\n    context?: ResolutionContext,\n): AwaitValuesInCollection<\n    InferProviderCollectionResolutions<Providers>\n> => {\n    const resolutions = providers.map((provider) => provider(context));\n\n    const hasPromises = resolutions.some(\n        (resolution) => resolution instanceof Promise,\n    );\n\n    return (hasPromises ? Promise.all(resolutions) : resolutions) as any;\n};\n\n/**\n * Calls every provider in a map with a provided resolution context\n * and returns a map with identical keys but with resolutions in values instead.\n * Returns a `Promise` of a map of awaited resolutions if there's at least one\n * `Promise` in the resolutions.\n *\n * @example\n * Only sync providers:\n * ```ts\n * const getA = scoped(() => createA())\n * const getB = scoped(() => createB())\n * const getC = scoped(() => createC())\n *\n * const scope = createScope()\n * const resolutions = resolveMap(\n *     { a: getA, b: getB, c: getC },\n *     { scope }\n * )\n *\n * resolutions == {\n *     a: getA({ scope }),\n *     b: getB({ scope }),\n *     c: getC({ scope })\n * }\n * ```\n *\n * @example\n * Some provider is async:\n * ```ts\n * const getA = scoped(() => createA())\n * const getB = scoped(async () => await createB())\n * const getC = scoped(() => createC())\n *\n * const scope = createScope()\n * const resolutions = await resolveMap(\n *     { a: getA, b: getB, c: getC },\n *     { scope }\n * )\n *\n * resolutions == {\n *     a: getA({ scope }),\n *     b: await getB({ scope }),\n *     c: getC({ scope })\n * }\n * ```\n *\n * @param providers - The map of providers.\n * @param context - The resolution context.\n *\n * @returns The map of resolutions.\n */\nexport const resolveMap = <const Providers extends ProviderRecord>(\n    providers: Providers,\n    context?: ResolutionContext,\n): AwaitValuesInCollection<\n    InferProviderCollectionResolutions<Providers>\n> => {\n    const resolutionMapEntries = Object.entries(providers).map(\n        ([key, provider]) => [key, provider(context)],\n    );\n\n    const hasPromises = resolutionMapEntries.some(\n        ([, resolution]) => resolution instanceof Promise,\n    );\n\n    if (hasPromises) {\n        return (async () => {\n            const awaitedEntries = await Promise.all(\n                resolutionMapEntries.map(async ([key, resolution]) => [\n                    key,\n                    await resolution,\n                ]),\n            );\n            return Object.fromEntries(awaitedEntries);\n        })() as any;\n    }\n\n    return Object.fromEntries(resolutionMapEntries);\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;AC2BA,IAAM,iBAAiB,CAAI,aAAuC;AAC9D,QAAM,WAAwB,CAAC,YAAY;AA5B/C;AA6BQ,UAAM,aAAY,wCAAS,UAAT,mBAAgB,IAAI;AACtC,QAAI,UAAW,QAAO,UAAU,OAAO;AAEvC,WAAO,SAAS,OAAO;AAAA,EAC3B;AAEA,SAAO,OAAO,OAAO,UAAU,EAAE,SAAS,WAAoB,CAAC;AACnE;AAiBO,IAAM,YAAY;AAkBlB,IAAM,YAAY,CAAI,aAAuC;AAChE,MAAI,WAAW;AACf,MAAI;AAEJ,QAAM,WAAW,eAAe,CAAC,YAAY;AACzC,QAAI,SAAU,QAAO;AAErB,iBAAa,SAAS,OAAO;AAC7B,eAAW;AAEX,WAAO;AAAA,EACX,CAAC;AAED,SAAO;AACX;AA0BO,IAAM,SAAS,CAAI,aAAuC;AAC7D,QAAM,oBAAoB,UAAU,QAAQ;AAE5C,QAAM,WAAW,eAAe,CAAC,YAAY;AACzC,QAAI,EAAC,mCAAS,OAAO,QAAO,kBAAkB,OAAO;AAErD,UAAM,aAAa,QAAQ,MAAM,IAAI,QAAQ,IACvC,QAAQ,MAAM,IAAI,QAAQ,IAC1B,SAAS,OAAO;AACtB,YAAQ,MAAM,IAAI,UAAU,UAAU;AAEtC,WAAO;AAAA,EACX,CAAC;AAED,SAAO;AACX;;;ACpGO,IAAM,cAAc,MAAa,oBAAI,IAAI;;;ACYzC,IAAM,gBAAgB,MAAe,oBAAI,IAAI;;;ACmC7C,IAAM,cAAc,CACvB,WACA,YAGC;AACD,QAAM,cAAc,UAAU,IAAI,CAAC,aAAa,SAAS,OAAO,CAAC;AAEjE,QAAM,cAAc,YAAY;AAAA,IAC5B,CAAC,eAAe,sBAAsB;AAAA,EAC1C;AAEA,SAAQ,cAAc,QAAQ,IAAI,WAAW,IAAI;AACrD;AAqDO,IAAM,aAAa,CACtB,WACA,YAGC;AACD,QAAM,uBAAuB,OAAO,QAAQ,SAAS,EAAE;AAAA,IACnD,CAAC,CAAC,KAAK,QAAQ,MAAM,CAAC,KAAK,SAAS,OAAO,CAAC;AAAA,EAChD;AAEA,QAAM,cAAc,qBAAqB;AAAA,IACrC,CAAC,CAAC,EAAE,UAAU,MAAM,sBAAsB;AAAA,EAC9C;AAEA,MAAI,aAAa;AACb,YAAQ,YAAY;AAChB,YAAM,iBAAiB,MAAM,QAAQ;AAAA,QACjC,qBAAqB,IAAI,OAAO,CAAC,KAAK,UAAU,MAAM;AAAA,UAClD;AAAA,UACA,MAAM;AAAA,QACV,CAAC;AAAA,MACL;AACA,aAAO,OAAO,YAAY,cAAc;AAAA,IAC5C,GAAG;AAAA,EACP;AAEA,SAAO,OAAO,YAAY,oBAAoB;AAClD;","names":[]}
+{"version":3,"sources":["../src/index.ts","../src/resolver.ts","../src/scope.ts","../src/mock-map.ts","../src/collection-resolution.ts"],"sourcesContent":["export * from \"./resolver\";\nexport * from \"./scope\";\nexport * from \"./mock-map\";\nexport * from \"./collection-resolution\";\n","import { MockMap } from \"./mock-map\";\nimport { Scope } from \"./scope\";\n\n/**\n * A function that takes a resolution context\n * and returns a value of some type.\n */\nexport type ResolverFn<T> = (context?: ResolutionContext) => T;\n\n/**\n * A function that returns a value of some type\n * based on a resolution context.\n */\nexport type Resolver<T> = ResolverFn<T>;\n\n/**\n * A context used by resolvers that defines the behaviour of the resolver\n * with the passed mocks and scope.\n */\nexport type ResolutionContext = {\n    scope?: Scope;\n    mocks?: MockMap;\n};\n\n/**\n * Makes the resolver function capable of replacing itself\n * with a mock if one is defined in the resolution context.\n */\nconst mockable = <T>(fn: ResolverFn<T>): ResolverFn<T> => {\n    const instance = (context?: ResolutionContext) => {\n        const mock = context?.mocks?.get(instance);\n        if (!mock) return fn(context);\n\n        if (!mock.isPartial) return mock.resolver(context);\n\n        const resolution = fn(context);\n        const mockResolution = mock.resolver(context);\n\n        if (resolution instanceof Promise && mockResolution instanceof Promise)\n            return Promise.all([resolution, mockResolution]).then(([a, b]) =>\n                Object.assign(a as object, b),\n            ) as T;\n\n        return Object.assign(resolution as object, mockResolution);\n    };\n\n    return instance;\n};\n\n/**\n * Creates a resolver that creates a new resolution on each call.\n *\n * @example\n * ```ts\n * const getEntity = transient(() => createEntity())\n * getEntity() !== getEntity()\n * ```\n *\n * @param resolver\n * A function that takes a resolution context\n * and returns a value of some type.\n *\n * @returns The transient resolver.\n */\nexport const transient = <T>(fn: ResolverFn<T>): Resolver<T> => mockable(fn);\n\n/**\n * Creates a resolver that creates\n * a resolution once and return it on each call.\n *\n * @example\n * ```ts\n * const getEntity = singleton(() => createEntity())\n * getEntity() === getEntity()\n * ```\n *\n * @param fn\n * A function that takes a resolution context\n * and returns a value of some type.\n *\n * @returns The singleton resolver.\n */\nexport const singleton = <T>(fn: ResolverFn<T>): Resolver<T> => {\n    let resolved = false;\n    let resolution: T | undefined;\n\n    const instance = mockable((context) => {\n        if (resolved) return resolution!;\n\n        resolution = fn(context);\n        resolved = true;\n\n        return resolution;\n    });\n\n    return instance;\n};\n\n/**\n * Creates a resolver that takes its resolution\n * from a scope or create a new one and save it if there is none.\n * If no scope was passed in a resolution context,\n * it will act as a singleton.\n *\n * @example\n * ```ts\n * const getEntity = scoped(() => createEntity())\n * getEntity() === getEntity()\n * ```\n *\n * @example\n * ```ts\n * const getEntity = scoped(() => createEntity())\n * const scope = createScope()\n * getEntity({ scope }) === getEntity({ scope }) !== getEntity()\n * ```\n *\n * @param fn\n * A function that takes a resolution context\n * and returns a value of some type.\n *\n * @returns The scoped resolver.\n */\nexport const scoped = <T>(fn: ResolverFn<T>): Resolver<T> => {\n    const singletonFallback = singleton(fn);\n\n    const instance = mockable((context) => {\n        if (!context?.scope) return singletonFallback(context);\n\n        const resolution = context.scope.has(instance)\n            ? context.scope.get(instance)\n            : fn(context);\n\n        context.scope.set(instance, resolution);\n\n        return resolution;\n    });\n\n    return instance;\n};\n","import { Resolver } from \"./resolver\";\n\n/**\n * A `Map` of resolvers to their resolutions.\n * Is passed in a resolution context and used by scoped resolvers\n * to retrieve or save resolution within it.\n */\nexport type Scope = Map<Resolver<any>, any>;\n\n/**\n * Creates a `Map` of providers to their instances.\n * Is passed in a resolution context and used by scoped resolvers\n * to retrieve or save resolution within it.\n *\n * @example\n * ```ts\n * const requestScope = createScope()\n *\n * app.use(() => {\n *     const db = getDb({ scope: requestScope })\n * })\n * ```\n *\n * @returns The map.\n */\nexport const createScope = (): Scope => new Map();\n","import { Resolver } from \"./resolver\";\n\ntype PromiseAwarePartial<T> =\n    T extends Promise<infer U> ? Promise<Partial<U>> : Partial<T>;\n\ntype Mock<T> =\n    | {\n          isPartial: false;\n          resolver: Resolver<T>;\n      }\n    | {\n          isPartial: true;\n          resolver: Resolver<PromiseAwarePartial<T>>;\n      };\n\ntype MocksEntries = [Resolver<any>, Mock<any>][];\n\n/**\n * Immutable map that registers and provides mocks.\n * Is passed in a resolution context and used by resolvers\n * to replace or partially replace themselves with a mock if one is defined.\n */\nexport type MockMap = {\n    /**\n     * Registers a mock for a resolver,\n     * creating a new `MockMap` with this registration.\n     *\n     * @param original - The original resolver.\n     * @param mock - The mock resolver.\n     */\n    mock<T>(original: Resolver<T>, mock: Resolver<T>): MockMap;\n    /**\n     * Registers a partial mock for a resolver,\n     * creating a new `MockMap` with this registration.\n     * In this case, the mock resolver's resolution object will be\n     * merged with the original resolver's resolution object,\n     * overwriting certain fields.\n     *\n     * @param original - The original resolver.\n     * @param mock - The mock resolver.\n     */\n    mockPartially<T extends object>(\n        original: Resolver<T>,\n        mock: Resolver<PromiseAwarePartial<T>>,\n    ): MockMap;\n    /**\n     * Returns a mock of a resolver\n     * or `undefined` if one is not registered.\n     *\n     * @param original - The original resolver.\n     */\n    get<T>(original: Resolver<T>): Mock<T> | undefined;\n};\n\n/**\n * Internal implementation that accepts entries.\n */\nconst createMockMapWithEntries = (entries: MocksEntries = []): MockMap => {\n    const set = (key: Resolver<any>, value: Mock<any>) =>\n        createMockMapWithEntries([\n            ...entries.filter((entry) => entry[0] !== key),\n            [key, value],\n        ]);\n\n    return {\n        mock(original, mock) {\n            return set(original, {\n                isPartial: false,\n                resolver: mock,\n            });\n        },\n        mockPartially(original, mock) {\n            return set(original, {\n                isPartial: true,\n                resolver: mock,\n            });\n        },\n        get(original) {\n            return entries.find((entry) => entry[0] === original)?.[1] as any;\n        },\n    };\n};\n\n/**\n * Creates a mock map, an immutable map that registers and provides mocks.\n * Is passed in a resolution context and used by resolvers\n * to replace or partially replace themselves with a mock if one is defined.\n *\n * @example\n * ```ts\n * const mocks = createMockMap()\n *     .mock(getDependency, getDependencyMock)\n *     .mockPartially(\n *         getOtherDepedency,\n *         transient(() => ({ someField: \"mock\" }))\n *     )\n *\n * const entityWithMocks = getEntity({ mocks })\n * ```\n *\n * @returns The mock map.\n */\nexport const createMockMap = (): MockMap => createMockMapWithEntries();\n","import { ResolutionContext, Resolver } from \"./resolver\";\n\ntype ResolverList = Resolver<any>[];\ntype ResolverRecord = Record<string, Resolver<any>>;\n\ntype InferResolverCollectionResolutions<\n    Resolvers extends ResolverList | ResolverRecord,\n> = {\n    [K in keyof Resolvers]: Resolvers[K] extends Resolver<infer T> ? T : never;\n};\n\n/**\n * Awaits all promises and wraps the collection in a promise\n * if there'ss at least one `Promise` in the collection,\n * otherwise returns an untouched type.\n */\ntype AwaitValuesInCollection<T extends any[] | Record<any, any>> =\n    Promise<any> extends T[keyof T]\n        ? Promise<{\n              [I in keyof T]: T[I] extends Promise<infer T> ? T : T[I];\n          }>\n        : T;\n\n/**\n * Calls every resolver in a list with a provided resolution context\n * and returns a list of resolutions. Returns a `Promise` of a list\n * of awaited resolutions if there's at least one `Promise` in the resolutions.\n *\n * @example\n * Only sync resolvers:\n * ```ts\n * const getA = scoped(() => createA())\n * const getB = scoped(() => createB())\n * const getC = scoped(() => createC())\n *\n * const scope = createScope()\n * const resolutions = resolveList(\n *     [getA, getB, getC],\n *     { scope }\n * )\n *\n * resolutions == [\n *     getA({ scope }),\n *     getB({ scope }),\n *     getC({ scope })\n * ]\n * ```\n *\n * @example\n * Some resolver is async:\n * ```ts\n * const getA = scoped(() => createA())\n * const getB = scoped(async () => await createB())\n * const getC = scoped(() => createC())\n *\n * const scope = createScope()\n * const resolutions = resolveList(\n *     [getA, getB, getC],\n *     { scope }\n * )\n *\n * resolutions == [\n *     getA({ scope }),\n *     await getB({ scope }),\n *     getC({ scope })\n * ]\n * ```\n *\n * @param resolvers - The list of resolvers.\n * @param context - The resolution context.\n *\n * @returns The list of resolutions.\n */\nexport const resolveList = <const Resolvers extends ResolverList>(\n    resolvers: Resolvers,\n    context?: ResolutionContext,\n): AwaitValuesInCollection<InferResolverCollectionResolutions<Resolvers>> => {\n    const resolutions = resolvers.map((resolver) => resolver(context));\n\n    const hasPromises = resolutions.some(\n        (resolution) => resolution instanceof Promise,\n    );\n\n    return (hasPromises ? Promise.all(resolutions) : resolutions) as any;\n};\n\n/**\n * Calls every resolver in a map with a provided resolution context\n * and returns a map with identical keys but with resolutions in values instead.\n * Returns a `Promise` of a map of awaited resolutions if there's at least one\n * `Promise` in the resolutions.\n *\n * @example\n * Only sync resolvers:\n * ```ts\n * const getA = scoped(() => createA())\n * const getB = scoped(() => createB())\n * const getC = scoped(() => createC())\n *\n * const scope = createScope()\n * const resolutions = resolveMap(\n *     { a: getA, b: getB, c: getC },\n *     { scope }\n * )\n *\n * resolutions == {\n *     a: getA({ scope }),\n *     b: getB({ scope }),\n *     c: getC({ scope })\n * }\n * ```\n *\n * @example\n * Some resolver is async:\n * ```ts\n * const getA = scoped(() => createA())\n * const getB = scoped(async () => await createB())\n * const getC = scoped(() => createC())\n *\n * const scope = createScope()\n * const resolutions = await resolveMap(\n *     { a: getA, b: getB, c: getC },\n *     { scope }\n * )\n *\n * resolutions == {\n *     a: getA({ scope }),\n *     b: await getB({ scope }),\n *     c: getC({ scope })\n * }\n * ```\n *\n * @param resolvers - The map of resolvers.\n * @param context - The resolution context.\n *\n * @returns The map of resolutions.\n */\nexport const resolveMap = <const Resolvers extends ResolverRecord>(\n    resolvers: Resolvers,\n    context?: ResolutionContext,\n): AwaitValuesInCollection<InferResolverCollectionResolutions<Resolvers>> => {\n    const resolutionMapEntries = Object.entries(resolvers).map(\n        ([key, resolver]) => [key, resolver(context)],\n    );\n\n    const hasPromises = resolutionMapEntries.some(\n        ([, resolution]) => resolution instanceof Promise,\n    );\n\n    if (hasPromises) {\n        return (async () => {\n            const awaitedEntries = await Promise.all(\n                resolutionMapEntries.map(async ([key, resolution]) => [\n                    key,\n                    await resolution,\n                ]),\n            );\n            return Object.fromEntries(awaitedEntries);\n        })() as any;\n    }\n\n    return Object.fromEntries(resolutionMapEntries);\n};\n"],"mappings":"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","names":[]}

package/dist/index.mjs

@@ -1,30 +1,37 @@
-// src/provider.ts
-var createProvider = (resolver) => {
+// src/resolver.ts
+var mockable = (fn) => {
   const instance = (context) => {
     var _a;
-    const maybeMock = (_a = context == null ? void 0 : context.mocks) == null ? void 0 : _a.get(instance);
-    if (maybeMock) return maybeMock(context);
-    return resolver(context);
+    const mock = (_a = context == null ? void 0 : context.mocks) == null ? void 0 : _a.get(instance);
+    if (!mock) return fn(context);
+    if (!mock.isPartial) return mock.resolver(context);
+    const resolution = fn(context);
+    const mockResolution = mock.resolver(context);
+    if (resolution instanceof Promise && mockResolution instanceof Promise)
+      return Promise.all([resolution, mockResolution]).then(
+        ([a, b]) => Object.assign(a, b)
+      );
+    return Object.assign(resolution, mockResolution);
   };
-  return Object.assign(instance, { __brand: "provider" });
+  return instance;
 };
-var transient = createProvider;
-var singleton = (resolver) => {
+var transient = (fn) => mockable(fn);
+var singleton = (fn) => {
   let resolved = false;
   let resolution;
-  const instance = createProvider((context) => {
+  const instance = mockable((context) => {
     if (resolved) return resolution;
-    resolution = resolver(context);
+    resolution = fn(context);
     resolved = true;
     return resolution;
   });
   return instance;
 };
-var scoped = (resolver) => {
-  const singletonFallback = singleton(resolver);
-  const instance = createProvider((context) => {
+var scoped = (fn) => {
+  const singletonFallback = singleton(fn);
+  const instance = mockable((context) => {
     if (!(context == null ? void 0 : context.scope)) return singletonFallback(context);
-    const resolution = context.scope.has(instance) ? context.scope.get(instance) : resolver(context);
+    const resolution = context.scope.has(instance) ? context.scope.get(instance) : fn(context);
     context.scope.set(instance, resolution);
     return resolution;
   });
@@ -35,19 +42,43 @@ var scoped = (resolver) => {
 var createScope = () => /* @__PURE__ */ new Map();
 
 // src/mock-map.ts
-var createMockMap = () => /* @__PURE__ */ new Map();
+var createMockMapWithEntries = (entries = []) => {
+  const set = (key, value) => createMockMapWithEntries([
+    ...entries.filter((entry) => entry[0] !== key),
+    [key, value]
+  ]);
+  return {
+    mock(original, mock) {
+      return set(original, {
+        isPartial: false,
+        resolver: mock
+      });
+    },
+    mockPartially(original, mock) {
+      return set(original, {
+        isPartial: true,
+        resolver: mock
+      });
+    },
+    get(original) {
+      var _a;
+      return (_a = entries.find((entry) => entry[0] === original)) == null ? void 0 : _a[1];
+    }
+  };
+};
+var createMockMap = () => createMockMapWithEntries();
 
 // src/collection-resolution.ts
-var resolveList = (providers, context) => {
-  const resolutions = providers.map((provider) => provider(context));
+var resolveList = (resolvers, context) => {
+  const resolutions = resolvers.map((resolver) => resolver(context));
   const hasPromises = resolutions.some(
     (resolution) => resolution instanceof Promise
   );
   return hasPromises ? Promise.all(resolutions) : resolutions;
 };
-var resolveMap = (providers, context) => {
-  const resolutionMapEntries = Object.entries(providers).map(
-    ([key, provider]) => [key, provider(context)]
+var resolveMap = (resolvers, context) => {
+  const resolutionMapEntries = Object.entries(resolvers).map(
+    ([key, resolver]) => [key, resolver(context)]
   );
   const hasPromises = resolutionMapEntries.some(
     ([, resolution]) => resolution instanceof Promise

package/dist/index.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/provider.ts","../src/scope.ts","../src/mock-map.ts","../src/collection-resolution.ts"],"sourcesContent":["import { MockMap } from \"./mock-map\";\nimport { Scope } from \"./scope\";\n\n/**\n * A function that returns a value of a particular type\n * with a resolution context being passed to it.\n */\nexport type Resolver<T> = (context?: ResolutionContext) => T;\n\n/**\n * A function that resolves an instance or a `Promise` of a particular type\n * based on a resolution context passed to it.\n */\nexport type Provider<T> = Resolver<T> & { __brand: \"provider\" };\n\n/**\n * A context used by providers to resolve instances\n * based on current scope and mocks.\n */\nexport type ResolutionContext = {\n    scope?: Scope;\n    mocks?: MockMap;\n};\n\n/**\n * Creating a nominal type value and introducing common functionality.\n */\nconst createProvider = <T>(resolver: Resolver<T>): Provider<T> => {\n    const instance: Resolver<T> = (context) => {\n        const maybeMock = context?.mocks?.get(instance);\n        if (maybeMock) return maybeMock(context);\n\n        return resolver(context);\n    };\n\n    return Object.assign(instance, { __brand: \"provider\" as const });\n};\n\n/**\n * Creates a transient provider that will resolve a new instance on each call.\n *\n * @example\n * ```ts\n * const getThing = transient(() => createThing())\n * getThing() !== getThing()\n * ```\n *\n * @param resolver\n * A function that returns a value of a particular type\n * with a resolution context being passed to it.\n *\n * @returns The transient provider.\n */\nexport const transient = createProvider;\n\n/**\n * Creates a singleton provider that will resolve an instance once\n * and return it on every call.\n *\n * @example\n * ```ts\n * const getThing = singleton(() => createThing())\n * getThing() === getThing()\n * ```\n *\n * @param resolver\n * A function that returns a value of a particular type\n * with a resolution context being passed to it.\n *\n * @returns The singleton provider.\n */\nexport const singleton = <T>(resolver: Resolver<T>): Provider<T> => {\n    let resolved = false;\n    let resolution: T | undefined;\n\n    const instance = createProvider((context) => {\n        if (resolved) return resolution!;\n\n        resolution = resolver(context);\n        resolved = true;\n\n        return resolution;\n    });\n\n    return instance;\n};\n\n/**\n * Creates a scoped provider that will take its resolution from a passed scope\n * or create a new one and save it if there is none.\n * If no scope is passed, it will act as a singleton.\n *\n * @example\n * ```ts\n * const getThing = scoped(() => createThing())\n * getThing() === getThing()\n * ```\n *\n * @example\n * ```ts\n * const getThing = scoped(() => createThing())\n * const scope = createScope()\n * getThing({ scope }) === getThing({ scope }) !== getThing()\n * ```\n *\n * @param resolver\n * A function that returns a value of a particular type\n * with a resolution context being passed to it.\n *\n * @returns The scoped provider.\n */\nexport const scoped = <T>(resolver: Resolver<T>): Provider<T> => {\n    const singletonFallback = singleton(resolver);\n\n    const instance = createProvider((context) => {\n        if (!context?.scope) return singletonFallback(context);\n\n        const resolution = context.scope.has(instance)\n            ? context.scope.get(instance)\n            : resolver(context);\n        context.scope.set(instance, resolution);\n\n        return resolution;\n    });\n\n    return instance;\n};\n","import { Resolver } from \"./provider\";\n\n/**\n * A `Map` of providers to their instances\n * that is then passed to a provider call in a resolution context object\n * to resolve instances of scoped providers within it.\n */\nexport type Scope = Map<Resolver<any>, any>;\n\n/**\n * Creates a `Map` of providers to their instances\n * that is then passed to a provider call in a resolution context object\n * to resolve instances of scoped providers within it.\n *\n * @example\n * ```ts\n * const requestScope = createScope()\n *\n * app.use(() => {\n *     const db = getDb({ scope: requestScope })\n *     // ...\n * })\n * ```\n *\n * @returns The map instance.\n */\nexport const createScope = (): Scope => new Map();\n","import { Resolver } from \"./provider\";\n\n/**\n * A `Map` of providers to providers of the same type\n * which is then passed to a provider call in a resolution context object\n * in order to replace providers with their mocks.\n */\nexport type MockMap = Omit<Map<Resolver<any>, Resolver<any>>, \"set\" | \"get\"> & {\n    /**\n     * Sets a mock for a provider.\n     *\n     * @param provider - The original provider.\n     * @param mock - The mock provider.\n     */\n    set<T>(provider: Resolver<T>, mock: Resolver<T>): MockMap;\n    /**\n     * Retrieves a mock of a provider. Returns undefined if there's none.\n     *\n     * @param provider - The provider.\n     */\n    get<T>(provider: Resolver<T>): Resolver<T> | undefined;\n};\n\n/**\n * Creates a `Map` of providers to providers of the same type\n * which is then passed to a provider call in a resolution context object\n * in order to replace providers with their mocks.\n *\n * @example\n * ```ts\n * const mocks = createMockMap()\n *     .set(getConfig, getTestConfig)\n *\n * getThing({ mocks })\n * ```\n *\n * @returns The map instance.\n */\nexport const createMockMap = (): MockMap => new Map();\n","import { Provider, ResolutionContext } from \"./provider\";\n\ntype ProviderList = Provider<any>[];\ntype ProviderRecord = Record<string, Provider<any>>;\n\ntype InferProviderCollectionResolutions<\n    Providers extends ProviderList | ProviderRecord,\n> = {\n    [K in keyof Providers]: Providers[K] extends Provider<infer T> ? T : never;\n};\n\n/**\n * Awaits all promises and wraps the collection in a promise\n * if there'ss at least one `Promise` in the collection,\n * otherwise returns an untouched type.\n */\ntype AwaitValuesInCollection<T extends any[] | Record<any, any>> =\n    Promise<any> extends T[keyof T]\n        ? Promise<{\n              [I in keyof T]: T[I] extends Promise<infer T> ? T : T[I];\n          }>\n        : T;\n\n/**\n * Calls every provider in a list with a provided resolution context\n * and returns a list of resolutions. Returns a `Promise` of a list\n * of awaited resolutions if there's at least one `Promise` in the resolutions.\n *\n * @example\n * Only sync providers:\n * ```ts\n * const getA = scoped(() => createA())\n * const getB = scoped(() => createB())\n * const getC = scoped(() => createC())\n *\n * const scope = createScope()\n * const resolutions = resolveList(\n *     [getA, getB, getC],\n *     { scope }\n * )\n *\n * resolutions == [\n *     getA({ scope }),\n *     getB({ scope }),\n *     getC({ scope })\n * ]\n * ```\n *\n * @example\n * Some provider is async:\n * ```ts\n * const getA = scoped(() => createA())\n * const getB = scoped(async () => await createB())\n * const getC = scoped(() => createC())\n *\n * const scope = createScope()\n * const resolutions = resolveList(\n *     [getA, getB, getC],\n *     { scope }\n * )\n *\n * resolutions == [\n *     getA({ scope }),\n *     await getB({ scope }),\n *     getC({ scope })\n * ]\n * ```\n *\n * @param providers - The list of providers.\n * @param context - The resolution context.\n *\n * @returns The list of resolutions.\n */\nexport const resolveList = <const Providers extends ProviderList>(\n    providers: Providers,\n    context?: ResolutionContext,\n): AwaitValuesInCollection<\n    InferProviderCollectionResolutions<Providers>\n> => {\n    const resolutions = providers.map((provider) => provider(context));\n\n    const hasPromises = resolutions.some(\n        (resolution) => resolution instanceof Promise,\n    );\n\n    return (hasPromises ? Promise.all(resolutions) : resolutions) as any;\n};\n\n/**\n * Calls every provider in a map with a provided resolution context\n * and returns a map with identical keys but with resolutions in values instead.\n * Returns a `Promise` of a map of awaited resolutions if there's at least one\n * `Promise` in the resolutions.\n *\n * @example\n * Only sync providers:\n * ```ts\n * const getA = scoped(() => createA())\n * const getB = scoped(() => createB())\n * const getC = scoped(() => createC())\n *\n * const scope = createScope()\n * const resolutions = resolveMap(\n *     { a: getA, b: getB, c: getC },\n *     { scope }\n * )\n *\n * resolutions == {\n *     a: getA({ scope }),\n *     b: getB({ scope }),\n *     c: getC({ scope })\n * }\n * ```\n *\n * @example\n * Some provider is async:\n * ```ts\n * const getA = scoped(() => createA())\n * const getB = scoped(async () => await createB())\n * const getC = scoped(() => createC())\n *\n * const scope = createScope()\n * const resolutions = await resolveMap(\n *     { a: getA, b: getB, c: getC },\n *     { scope }\n * )\n *\n * resolutions == {\n *     a: getA({ scope }),\n *     b: await getB({ scope }),\n *     c: getC({ scope })\n * }\n * ```\n *\n * @param providers - The map of providers.\n * @param context - The resolution context.\n *\n * @returns The map of resolutions.\n */\nexport const resolveMap = <const Providers extends ProviderRecord>(\n    providers: Providers,\n    context?: ResolutionContext,\n): AwaitValuesInCollection<\n    InferProviderCollectionResolutions<Providers>\n> => {\n    const resolutionMapEntries = Object.entries(providers).map(\n        ([key, provider]) => [key, provider(context)],\n    );\n\n    const hasPromises = resolutionMapEntries.some(\n        ([, resolution]) => resolution instanceof Promise,\n    );\n\n    if (hasPromises) {\n        return (async () => {\n            const awaitedEntries = await Promise.all(\n                resolutionMapEntries.map(async ([key, resolution]) => [\n                    key,\n                    await resolution,\n                ]),\n            );\n            return Object.fromEntries(awaitedEntries);\n        })() as any;\n    }\n\n    return Object.fromEntries(resolutionMapEntries);\n};\n"],"mappings":";AA2BA,IAAM,iBAAiB,CAAI,aAAuC;AAC9D,QAAM,WAAwB,CAAC,YAAY;AA5B/C;AA6BQ,UAAM,aAAY,wCAAS,UAAT,mBAAgB,IAAI;AACtC,QAAI,UAAW,QAAO,UAAU,OAAO;AAEvC,WAAO,SAAS,OAAO;AAAA,EAC3B;AAEA,SAAO,OAAO,OAAO,UAAU,EAAE,SAAS,WAAoB,CAAC;AACnE;AAiBO,IAAM,YAAY;AAkBlB,IAAM,YAAY,CAAI,aAAuC;AAChE,MAAI,WAAW;AACf,MAAI;AAEJ,QAAM,WAAW,eAAe,CAAC,YAAY;AACzC,QAAI,SAAU,QAAO;AAErB,iBAAa,SAAS,OAAO;AAC7B,eAAW;AAEX,WAAO;AAAA,EACX,CAAC;AAED,SAAO;AACX;AA0BO,IAAM,SAAS,CAAI,aAAuC;AAC7D,QAAM,oBAAoB,UAAU,QAAQ;AAE5C,QAAM,WAAW,eAAe,CAAC,YAAY;AACzC,QAAI,EAAC,mCAAS,OAAO,QAAO,kBAAkB,OAAO;AAErD,UAAM,aAAa,QAAQ,MAAM,IAAI,QAAQ,IACvC,QAAQ,MAAM,IAAI,QAAQ,IAC1B,SAAS,OAAO;AACtB,YAAQ,MAAM,IAAI,UAAU,UAAU;AAEtC,WAAO;AAAA,EACX,CAAC;AAED,SAAO;AACX;;;ACpGO,IAAM,cAAc,MAAa,oBAAI,IAAI;;;ACYzC,IAAM,gBAAgB,MAAe,oBAAI,IAAI;;;ACmC7C,IAAM,cAAc,CACvB,WACA,YAGC;AACD,QAAM,cAAc,UAAU,IAAI,CAAC,aAAa,SAAS,OAAO,CAAC;AAEjE,QAAM,cAAc,YAAY;AAAA,IAC5B,CAAC,eAAe,sBAAsB;AAAA,EAC1C;AAEA,SAAQ,cAAc,QAAQ,IAAI,WAAW,IAAI;AACrD;AAqDO,IAAM,aAAa,CACtB,WACA,YAGC;AACD,QAAM,uBAAuB,OAAO,QAAQ,SAAS,EAAE;AAAA,IACnD,CAAC,CAAC,KAAK,QAAQ,MAAM,CAAC,KAAK,SAAS,OAAO,CAAC;AAAA,EAChD;AAEA,QAAM,cAAc,qBAAqB;AAAA,IACrC,CAAC,CAAC,EAAE,UAAU,MAAM,sBAAsB;AAAA,EAC9C;AAEA,MAAI,aAAa;AACb,YAAQ,YAAY;AAChB,YAAM,iBAAiB,MAAM,QAAQ;AAAA,QACjC,qBAAqB,IAAI,OAAO,CAAC,KAAK,UAAU,MAAM;AAAA,UAClD;AAAA,UACA,MAAM;AAAA,QACV,CAAC;AAAA,MACL;AACA,aAAO,OAAO,YAAY,cAAc;AAAA,IAC5C,GAAG;AAAA,EACP;AAEA,SAAO,OAAO,YAAY,oBAAoB;AAClD;","names":[]}
+{"version":3,"sources":["../src/resolver.ts","../src/scope.ts","../src/mock-map.ts","../src/collection-resolution.ts"],"sourcesContent":["import { MockMap } from \"./mock-map\";\nimport { Scope } from \"./scope\";\n\n/**\n * A function that takes a resolution context\n * and returns a value of some type.\n */\nexport type ResolverFn<T> = (context?: ResolutionContext) => T;\n\n/**\n * A function that returns a value of some type\n * based on a resolution context.\n */\nexport type Resolver<T> = ResolverFn<T>;\n\n/**\n * A context used by resolvers that defines the behaviour of the resolver\n * with the passed mocks and scope.\n */\nexport type ResolutionContext = {\n    scope?: Scope;\n    mocks?: MockMap;\n};\n\n/**\n * Makes the resolver function capable of replacing itself\n * with a mock if one is defined in the resolution context.\n */\nconst mockable = <T>(fn: ResolverFn<T>): ResolverFn<T> => {\n    const instance = (context?: ResolutionContext) => {\n        const mock = context?.mocks?.get(instance);\n        if (!mock) return fn(context);\n\n        if (!mock.isPartial) return mock.resolver(context);\n\n        const resolution = fn(context);\n        const mockResolution = mock.resolver(context);\n\n        if (resolution instanceof Promise && mockResolution instanceof Promise)\n            return Promise.all([resolution, mockResolution]).then(([a, b]) =>\n                Object.assign(a as object, b),\n            ) as T;\n\n        return Object.assign(resolution as object, mockResolution);\n    };\n\n    return instance;\n};\n\n/**\n * Creates a resolver that creates a new resolution on each call.\n *\n * @example\n * ```ts\n * const getEntity = transient(() => createEntity())\n * getEntity() !== getEntity()\n * ```\n *\n * @param resolver\n * A function that takes a resolution context\n * and returns a value of some type.\n *\n * @returns The transient resolver.\n */\nexport const transient = <T>(fn: ResolverFn<T>): Resolver<T> => mockable(fn);\n\n/**\n * Creates a resolver that creates\n * a resolution once and return it on each call.\n *\n * @example\n * ```ts\n * const getEntity = singleton(() => createEntity())\n * getEntity() === getEntity()\n * ```\n *\n * @param fn\n * A function that takes a resolution context\n * and returns a value of some type.\n *\n * @returns The singleton resolver.\n */\nexport const singleton = <T>(fn: ResolverFn<T>): Resolver<T> => {\n    let resolved = false;\n    let resolution: T | undefined;\n\n    const instance = mockable((context) => {\n        if (resolved) return resolution!;\n\n        resolution = fn(context);\n        resolved = true;\n\n        return resolution;\n    });\n\n    return instance;\n};\n\n/**\n * Creates a resolver that takes its resolution\n * from a scope or create a new one and save it if there is none.\n * If no scope was passed in a resolution context,\n * it will act as a singleton.\n *\n * @example\n * ```ts\n * const getEntity = scoped(() => createEntity())\n * getEntity() === getEntity()\n * ```\n *\n * @example\n * ```ts\n * const getEntity = scoped(() => createEntity())\n * const scope = createScope()\n * getEntity({ scope }) === getEntity({ scope }) !== getEntity()\n * ```\n *\n * @param fn\n * A function that takes a resolution context\n * and returns a value of some type.\n *\n * @returns The scoped resolver.\n */\nexport const scoped = <T>(fn: ResolverFn<T>): Resolver<T> => {\n    const singletonFallback = singleton(fn);\n\n    const instance = mockable((context) => {\n        if (!context?.scope) return singletonFallback(context);\n\n        const resolution = context.scope.has(instance)\n            ? context.scope.get(instance)\n            : fn(context);\n\n        context.scope.set(instance, resolution);\n\n        return resolution;\n    });\n\n    return instance;\n};\n","import { Resolver } from \"./resolver\";\n\n/**\n * A `Map` of resolvers to their resolutions.\n * Is passed in a resolution context and used by scoped resolvers\n * to retrieve or save resolution within it.\n */\nexport type Scope = Map<Resolver<any>, any>;\n\n/**\n * Creates a `Map` of providers to their instances.\n * Is passed in a resolution context and used by scoped resolvers\n * to retrieve or save resolution within it.\n *\n * @example\n * ```ts\n * const requestScope = createScope()\n *\n * app.use(() => {\n *     const db = getDb({ scope: requestScope })\n * })\n * ```\n *\n * @returns The map.\n */\nexport const createScope = (): Scope => new Map();\n","import { Resolver } from \"./resolver\";\n\ntype PromiseAwarePartial<T> =\n    T extends Promise<infer U> ? Promise<Partial<U>> : Partial<T>;\n\ntype Mock<T> =\n    | {\n          isPartial: false;\n          resolver: Resolver<T>;\n      }\n    | {\n          isPartial: true;\n          resolver: Resolver<PromiseAwarePartial<T>>;\n      };\n\ntype MocksEntries = [Resolver<any>, Mock<any>][];\n\n/**\n * Immutable map that registers and provides mocks.\n * Is passed in a resolution context and used by resolvers\n * to replace or partially replace themselves with a mock if one is defined.\n */\nexport type MockMap = {\n    /**\n     * Registers a mock for a resolver,\n     * creating a new `MockMap` with this registration.\n     *\n     * @param original - The original resolver.\n     * @param mock - The mock resolver.\n     */\n    mock<T>(original: Resolver<T>, mock: Resolver<T>): MockMap;\n    /**\n     * Registers a partial mock for a resolver,\n     * creating a new `MockMap` with this registration.\n     * In this case, the mock resolver's resolution object will be\n     * merged with the original resolver's resolution object,\n     * overwriting certain fields.\n     *\n     * @param original - The original resolver.\n     * @param mock - The mock resolver.\n     */\n    mockPartially<T extends object>(\n        original: Resolver<T>,\n        mock: Resolver<PromiseAwarePartial<T>>,\n    ): MockMap;\n    /**\n     * Returns a mock of a resolver\n     * or `undefined` if one is not registered.\n     *\n     * @param original - The original resolver.\n     */\n    get<T>(original: Resolver<T>): Mock<T> | undefined;\n};\n\n/**\n * Internal implementation that accepts entries.\n */\nconst createMockMapWithEntries = (entries: MocksEntries = []): MockMap => {\n    const set = (key: Resolver<any>, value: Mock<any>) =>\n        createMockMapWithEntries([\n            ...entries.filter((entry) => entry[0] !== key),\n            [key, value],\n        ]);\n\n    return {\n        mock(original, mock) {\n            return set(original, {\n                isPartial: false,\n                resolver: mock,\n            });\n        },\n        mockPartially(original, mock) {\n            return set(original, {\n                isPartial: true,\n                resolver: mock,\n            });\n        },\n        get(original) {\n            return entries.find((entry) => entry[0] === original)?.[1] as any;\n        },\n    };\n};\n\n/**\n * Creates a mock map, an immutable map that registers and provides mocks.\n * Is passed in a resolution context and used by resolvers\n * to replace or partially replace themselves with a mock if one is defined.\n *\n * @example\n * ```ts\n * const mocks = createMockMap()\n *     .mock(getDependency, getDependencyMock)\n *     .mockPartially(\n *         getOtherDepedency,\n *         transient(() => ({ someField: \"mock\" }))\n *     )\n *\n * const entityWithMocks = getEntity({ mocks })\n * ```\n *\n * @returns The mock map.\n */\nexport const createMockMap = (): MockMap => createMockMapWithEntries();\n","import { ResolutionContext, Resolver } from \"./resolver\";\n\ntype ResolverList = Resolver<any>[];\ntype ResolverRecord = Record<string, Resolver<any>>;\n\ntype InferResolverCollectionResolutions<\n    Resolvers extends ResolverList | ResolverRecord,\n> = {\n    [K in keyof Resolvers]: Resolvers[K] extends Resolver<infer T> ? T : never;\n};\n\n/**\n * Awaits all promises and wraps the collection in a promise\n * if there'ss at least one `Promise` in the collection,\n * otherwise returns an untouched type.\n */\ntype AwaitValuesInCollection<T extends any[] | Record<any, any>> =\n    Promise<any> extends T[keyof T]\n        ? Promise<{\n              [I in keyof T]: T[I] extends Promise<infer T> ? T : T[I];\n          }>\n        : T;\n\n/**\n * Calls every resolver in a list with a provided resolution context\n * and returns a list of resolutions. Returns a `Promise` of a list\n * of awaited resolutions if there's at least one `Promise` in the resolutions.\n *\n * @example\n * Only sync resolvers:\n * ```ts\n * const getA = scoped(() => createA())\n * const getB = scoped(() => createB())\n * const getC = scoped(() => createC())\n *\n * const scope = createScope()\n * const resolutions = resolveList(\n *     [getA, getB, getC],\n *     { scope }\n * )\n *\n * resolutions == [\n *     getA({ scope }),\n *     getB({ scope }),\n *     getC({ scope })\n * ]\n * ```\n *\n * @example\n * Some resolver is async:\n * ```ts\n * const getA = scoped(() => createA())\n * const getB = scoped(async () => await createB())\n * const getC = scoped(() => createC())\n *\n * const scope = createScope()\n * const resolutions = resolveList(\n *     [getA, getB, getC],\n *     { scope }\n * )\n *\n * resolutions == [\n *     getA({ scope }),\n *     await getB({ scope }),\n *     getC({ scope })\n * ]\n * ```\n *\n * @param resolvers - The list of resolvers.\n * @param context - The resolution context.\n *\n * @returns The list of resolutions.\n */\nexport const resolveList = <const Resolvers extends ResolverList>(\n    resolvers: Resolvers,\n    context?: ResolutionContext,\n): AwaitValuesInCollection<InferResolverCollectionResolutions<Resolvers>> => {\n    const resolutions = resolvers.map((resolver) => resolver(context));\n\n    const hasPromises = resolutions.some(\n        (resolution) => resolution instanceof Promise,\n    );\n\n    return (hasPromises ? Promise.all(resolutions) : resolutions) as any;\n};\n\n/**\n * Calls every resolver in a map with a provided resolution context\n * and returns a map with identical keys but with resolutions in values instead.\n * Returns a `Promise` of a map of awaited resolutions if there's at least one\n * `Promise` in the resolutions.\n *\n * @example\n * Only sync resolvers:\n * ```ts\n * const getA = scoped(() => createA())\n * const getB = scoped(() => createB())\n * const getC = scoped(() => createC())\n *\n * const scope = createScope()\n * const resolutions = resolveMap(\n *     { a: getA, b: getB, c: getC },\n *     { scope }\n * )\n *\n * resolutions == {\n *     a: getA({ scope }),\n *     b: getB({ scope }),\n *     c: getC({ scope })\n * }\n * ```\n *\n * @example\n * Some resolver is async:\n * ```ts\n * const getA = scoped(() => createA())\n * const getB = scoped(async () => await createB())\n * const getC = scoped(() => createC())\n *\n * const scope = createScope()\n * const resolutions = await resolveMap(\n *     { a: getA, b: getB, c: getC },\n *     { scope }\n * )\n *\n * resolutions == {\n *     a: getA({ scope }),\n *     b: await getB({ scope }),\n *     c: getC({ scope })\n * }\n * ```\n *\n * @param resolvers - The map of resolvers.\n * @param context - The resolution context.\n *\n * @returns The map of resolutions.\n */\nexport const resolveMap = <const Resolvers extends ResolverRecord>(\n    resolvers: Resolvers,\n    context?: ResolutionContext,\n): AwaitValuesInCollection<InferResolverCollectionResolutions<Resolvers>> => {\n    const resolutionMapEntries = Object.entries(resolvers).map(\n        ([key, resolver]) => [key, resolver(context)],\n    );\n\n    const hasPromises = resolutionMapEntries.some(\n        ([, resolution]) => resolution instanceof Promise,\n    );\n\n    if (hasPromises) {\n        return (async () => {\n            const awaitedEntries = await Promise.all(\n                resolutionMapEntries.map(async ([key, resolution]) => [\n                    key,\n                    await resolution,\n                ]),\n            );\n            return Object.fromEntries(awaitedEntries);\n        })() as any;\n    }\n\n    return Object.fromEntries(resolutionMapEntries);\n};\n"],"mappings":"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","names":[]}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "atomic-di",
-  "version": "2.0.0",
-  "description": "Lifetimes, scopes and mocking for pure dependency injection.",
+  "version": "2.0.2",
+  "description": "Lifetimes, scopes and mocking for pure dependency injection",
   "repository": "https://github.com/ncor/atomic-di",
   "bugs": "https://github.com/ncor/atomic-di/issues",
   "homepage": "https://github.com/ncor/atomic-di#readme",