atomic-di 0.7.1-beta.1 → 0.8.0-beta.1

package/dist/index.d.mts

@@ -1,216 +1,229 @@
+type Entry<K, V> = [K, V];
+type Entries<K, V> = Entry<K, V>[];
 /**
- * A map of providers to their instances.
- * Passed to the provider call to resolve instances
- * of scoped providers within it.
- */
-type Scope = WeakMap<Provider<any>, any>;
-/**
- * Creates a new scope, map of providers to their instances.
- * Scope is passed to the provider call to resolve instances
- * of scoped providers within it.
- *
- * @returns A new scope.
+ * An immutable map. It's similar to `Map`,
+ * but with reduced functionality and readonly builder behavior.
  */
-declare const createScope: () => Scope;
-
-type MockMapEntries = [Provider<any>, Provider<any>][];
-/**
- * Stores and provides provider mocks.
- */
-type MockMap = {
-    entries: MockMapEntries;
+type ImmutableMap<K, V> = {
+    /**
+     * Map's entries.
+     */
+    readonly entries: Entries<K, V>;
     /**
-     * Returns the provider's mock or the provider itself
-     * depending on the presence of the mock.
+     * Retrieves a possibly existing value under a key.
      *
-     * @param provider - An original provider whose mock is needed to get.
+     * @param key - The key associated with the value.
      *
-     * @returns The passed provider or its mock.
+     * @returns The value or undefined.
      */
-    map<T>(provider: Provider<T>): Provider<T>;
+    get(key: K): V | undefined;
     /**
-     * Registers a mock provider and retursns a new mock map with that mock.
+     * Sets a value under a key.
      *
-     * @param provider - An original provider.
-     * @param replacement - A provider that will be a mock of the first provider.
+     * @param key - The key that will be associated with the value.
+     * @param value - The value to set.
      *
-     * @returns A new mock map with added mock.
+     * @returns A modified immutable map with the value being set in it.
      */
-    add<T>(provider: Provider<T>, replacement: Provider<T>): MockMap;
+    set(key: K, value: V): ImmutableMap<K, V>;
     /**
-     * Applies mocks from another map to the current one and returns a new map.
-     * If there are identical keys (original providers),
-     * they will be overwritten by mocks from the other map.
+     * Merges two immutable maps. If there're any matching keys,
+     * values from the second map will override values from the first map.
      *
-     * @param otherMockMap - A mock map that will be applied.
+     * @param other The second immutable map.
      *
-     * @returns A new mock map with applied mocks.
+     * @returns A new immutable map as a result of merging two maps.
      */
-    apply(otherMockMap: MockMap): MockMap;
+    merge(other: ImmutableMap<K, V>): ImmutableMap<K, V>;
 };
+
+/**
+ * A map of providers to their compatible versions.
+ *
+ * Passed to a provider call in a resolution context object
+ * in order to replace providers with their mocks.
+ * ```ts
+ * const mocks = createMockMap().set(otherProvider, otherProviderMock)
+ * provider({ mocks })
+ * ```
+ */
+type MockMap = ImmutableMap<Provider<any>, Provider<any>>;
 /**
- * Creates a new mock map that stores and provides provider mocks.
+ * Creates a mock map instance.
  *
- * @param entries - Entries of a mock map.
+ * Passed to a provider call in a resolution context object
+ * in order to replace providers with their mocks.
+ * ```ts
+ * const mocks = createMockMap().set(otherProvider, otherProviderMock)
+ * provider({ mocks })
+ * ```
  *
- * @returns A new mock map.
+ * @returns The mock map instance.
  */
-declare const createMockMap: (entries?: MockMapEntries) => {
-    entries: MockMapEntries;
-    map: <T>(provider: Provider<T>) => Provider<T>;
-    add: <T>(provider: Provider<T>, replacement: Provider<T>) => MockMap;
-    apply: (otherMockMap: MockMap) => MockMap;
-};
+declare const createMockMap: () => MockMap;
 
 /**
- * Calls a resolver(factory) with an optional scope and a mock map
- * and returns an instance.
+ * A map of providers to their instances.
  *
- * A passed scope will be propagated up a graph and will be passed
- * to all scoped providers to resolve their instance within this scope.
- * If a provider is scoped, it will either create a new instance
- * and store it in the scope, or retrieve an already created instance
- * from the scope.
+ * Passed to a provider call in a resolution context object
+ * to resolve instances of scoped providers within it.
+ * ```ts
+ * const scope = createScope()
+ * provider({ scope })
+ * ```
+ */
+type Scope = Map<Provider<any>, any>;
+/**
+ * Creates a scope instance.
+ *
+ * Scope is passed to a provider call in a resolution context object
+ * to resolve instances of scoped providers within it.
+ * ```ts
+ * const scope = createScope()
+ * provider({ scope })
+ * ```
  *
- * It is also possible to explicitly pass a mock map, but It's not recommended.
- * If you want to mock(replace) providers for a resolution,
- * it's best to use `mock` method.
+ * @returns The scope instance.
  */
-type ProviderCallable<T> = (scope?: Scope, mockMap?: MockMap) => T;
+declare const createScope: () => Scope;
+
 /**
- * Instance factory with lifetime and dynamic context.
+ * A wrapper around the resolver for contextual dependency resolution.
+ *
+ * Resolves an instance by calling a resolver
+ * with a resolution context that will be propagated
+ * throughout a dependency tree.
+ *
+ * When passing a scope it will try to get an instance from it
+ * or create a new one and put it there.
+ *
+ * When passing mocks, it will try to get its own mock version,
+ * and if there is one, it will use it instead of itself.
+ */
+type Provider<T> = (context?: ResolutionContext) => T;
+/**
+ * A resolution lifetime.
+ *
+ * Passed when creating a provider to determine its behavior.
+ *
+ * `"transient"` doesn't provide any modifications to a resolver behaviour,
+ * so the resolver will create a new instance on each request.
+ *
+ * `"singleton"` forces the resolver to create an instance once
+ * and return it in subsequent requests.
+ *
+ * `"scoped"` forces the resolver to take its instance from a provided scope
+ * or create a new one and save it if there is none.
+ * If no scope is passed, it will create a new instance on each request.
  */
-type Provider<T> = ProviderCallable<T> & {
-    /**
-     * Mocks(replaces) a provider within the visible graph,
-     * returning a new provider with that mock.
-     *
-     * @param dependencyProvider A provider used by the current provider
-     * that needs to be replaced.
-     * @param replacement A provider with a same interface
-     * that will be a replacement for the first one.
-     *
-     * @returns A new provider with the mocked dependency provider.
-     */
-    mock<U>(dependencyProvider: Provider<U>, replacement: Provider<U>): Provider<T>;
-};
 type Lifetime = "transient" | "singleton" | "scoped";
 /**
- * A function that resolves an instance of a passed provider.
- * It's needed to resolve correct instance in a scope
- * and to use mock of the passed provider, if any.
+ * A function that creates an instance using a resolution context.
  */
-type UseFn = <T>(provider: Provider<T>) => T;
+type Resolver<T> = (context?: ResolutionContext) => T;
 /**
- * A function that creates an instance by resolving its dependencies.
- * If there are dependencies, you must use `use` function passed
- * in the first argument.
+ * An object that holds information about a scope and provider mocks.
+ *
+ * Passed to the provider call to resolve scope instances and mock providers.
  */
-type Resolver<T> = (use: UseFn) => T;
+type ResolutionContext = {
+    scope?: Scope;
+    mocks?: MockMap;
+};
 /**
- * Creates a new provider, instance factory with lifetime and dynamic context.
+ * Creates a provider instance,
+ * a wrapper around a resolver for contextual dependency resolution.
+ *
+ * @param lifetime
+ * A resolution lifetime.
+ *
+ * `"transient"` doesn't provide any modifications to a resolver behaviour,
+ * so the resolver will create a new instance on each request.
  *
- * @param lifetime - Instance lifetime.
+ * `"singleton"` forces the resolver to create an instance once
+ * and return it in subsequent requests.
  *
- * @param resolver - A function that creates an instance
- * by resolving its dependencies
- * If there are dependencies, you must use `use` function passed
- * in the first argument.
+ * `"scoped"` forces the resolver to take its resolution from a provided scope
+ * or create a new one and save it if there is none.
+ * If no scope is passed, it will create a new instance on each request.
  *
- * @param mockMap - An optional mock map. Not recommended to specify explicitly,
- * use `mock` method to mock providers.
+ * @param resolver
+ * The function that creates an instance using a resolution context.
  *
- * @returns A new provider.
+ * @returns The provider instance.
  */
-declare const provide: <T>(lifetime: Lifetime, resolver: Resolver<T>, mockMap?: MockMap) => Provider<T>;
+declare const provide: <T>(lifetime: Lifetime, resolver: Resolver<T>) => Provider<T>;
 /**
- * Creates a new transient provider.
- * This provider will return a new instance on each resolution.
+ * Creates a transient provider instance,
+ * a wrapper around a resolver for contextual dependency resolution
+ * that will create a new instance on each request.
  *
- * @param resolver - A function that creates an instance
- * by resolving its dependencies
- * If there are dependencies, you must use `use` function passed
- * in the first argument.
+ * @param resolver
+ * The function that creates an instance using a resolution context.
  *
- * @returns A new transient provider.
+ * @returns The transient provider instance.
  */
 declare const transient: <T>(resolver: Resolver<T>) => Provider<T>;
 /**
- * Creates a new singleton provider.
- * This provider will create an instance once and return it on every request.
+ * Creates a transient provider instance,
+ * a wrapper around a resolver for contextual dependency resolution
+ * that will create an instance once and return it in subsequent requests.
  *
- * @param resolver - A function that creates an instance
- * by resolving its dependencies
- * If there are dependencies, you must use `use` function passed
- * in the first argument.
+ * @param resolver
+ * The function that creates an instance using a resolution context.
  *
- * @returns A new singleton provider.
+ * @returns The singleton provider instance.
  */
 declare const singleton: <T>(resolver: Resolver<T>) => Provider<T>;
 /**
- * Creates a new transient provider.
- * This provider will save the instance in scope on first resolution
- * and will retrieve it from scope on next resolutions.
- * If scope was not specified, will create a new instance on each resolution.
+ * Creates a transient provider instance,
+ * a wrapper around a resolver for contextual dependency resolution
+ * that will take its resolution from a provided scope
+ * or create a new one and save it if there is none.
+ * If no scope is passed, it will create a new instance on each request.
  *
- * @param resolver - A function that creates an instance
- * by resolving its dependencies
- * If there are dependencies, you must use `use` function passed
- * in the first argument.
+ * @param resolver
+ * The function that creates an instance using a resolution context.
  *
- * @returns A new scoped provider.
+ * @returns The scoped provider instance.
  */
 declare const scoped: <T>(resolver: Resolver<T>) => Provider<T>;
 
-/**
- * A map of string keys to providers.
- */
-type ProviderMap = Record<string, Provider<any>>;
-type InferProviderMapOutputs<Providers extends ProviderMap> = {
+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;
 };
 /**
- * Resolves all providers in a `ProviderMap` and
- * returns an object containing their instances.
- *
- * @param scope - An optional scope to use for scoped providers.
- * @param mockMap - An optional mock map to use for mocking providers.
- *
- * @returns An object containing the resolved instances of the providers.
+ * Awaits all promises and wraps the collection in a promise
+ * if there'ss at least one `Promise` in the collection,
+ * otherwise returns an untouched type.
  */
-type ProviderSelectionCallable<Providers extends ProviderMap> = (scope?: Scope, mockMap?: MockMap) => InferProviderMapOutputs<Providers>;
+type AwaitAllValuesInCollection<T extends any[] | Record<any, any>> = Promise<any> extends T[keyof T] ? Promise<{
+    [I in keyof T]: T[I] extends Promise<infer T> ? T : T[I];
+}> : T;
 /**
- * A selection of providers.
+ * Calls every provider 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.
+ *
+ * @param providers - The list of providers.
+ * @param context - The resolution context.
  *
- * @property map - The `ProviderMap` that the selection is based on.
- * @property mock - A function that mocks a provider within the selection,
- * returning a new `ProviderSelection` with the mock applied.
+ * @returns The list of resolutions.
  */
-type ProviderSelection<Providers extends ProviderMap> = ProviderSelectionCallable<Providers> & {
-    /**
-     * The `ProviderMap` that the selection is based on.
-     */
-    map: Providers;
-    /**
-     * Mocks a provider within the selection, returning a new
-     * `ProviderSelection` with the mock applied.
-     *
-     * @param dependencyProvider - A provider used by the current provider
-     * that needs to be replaced.
-     * @param replacement - A provider with a same interface that will be
-     * a replacement for the first one.
-     *
-     * @returns A new `ProviderSelection` with the mocked provider.
-     */
-    mock<T>(dependencyProvider: Provider<T>, replacement: Provider<T>): ProviderSelection<Providers>;
-};
+declare const resolveList: <const Providers extends ProviderList>(providers: Providers, context?: ResolutionContext) => AwaitAllValuesInCollection<InferProviderCollectionResolutions<Providers>>;
 /**
- * Creates a new provider selection from a provider map.
+ * Calls every provider 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.
  *
- * @param map - A map of string keys to providers.
+ * @param providers - The map of providers.
+ * @param context - The resolution context.
  *
- * @returns A new provider selection.
+ * @returns The map of resolutions.
  */
-declare const select: <Providers extends ProviderMap>(map: Providers) => ProviderSelection<Providers>;
+declare const resolveMap: <const Providers extends ProviderRecord>(providers: Providers, context?: ResolutionContext) => AwaitAllValuesInCollection<InferProviderCollectionResolutions<Providers>>;
 
-export { type MockMap, type Provider, type ProviderSelection, type Scope, createMockMap, createScope, provide, scoped, select, singleton, transient };
+export { type Lifetime, type MockMap, type Provider, type ResolutionContext, type Resolver, type Scope, createMockMap, createScope, provide, resolveList, resolveMap, scoped, singleton, transient };

package/dist/index.d.ts

@@ -1,216 +1,229 @@
+type Entry<K, V> = [K, V];
+type Entries<K, V> = Entry<K, V>[];
 /**
- * A map of providers to their instances.
- * Passed to the provider call to resolve instances
- * of scoped providers within it.
- */
-type Scope = WeakMap<Provider<any>, any>;
-/**
- * Creates a new scope, map of providers to their instances.
- * Scope is passed to the provider call to resolve instances
- * of scoped providers within it.
- *
- * @returns A new scope.
+ * An immutable map. It's similar to `Map`,
+ * but with reduced functionality and readonly builder behavior.
  */
-declare const createScope: () => Scope;
-
-type MockMapEntries = [Provider<any>, Provider<any>][];
-/**
- * Stores and provides provider mocks.
- */
-type MockMap = {
-    entries: MockMapEntries;
+type ImmutableMap<K, V> = {
+    /**
+     * Map's entries.
+     */
+    readonly entries: Entries<K, V>;
     /**
-     * Returns the provider's mock or the provider itself
-     * depending on the presence of the mock.
+     * Retrieves a possibly existing value under a key.
      *
-     * @param provider - An original provider whose mock is needed to get.
+     * @param key - The key associated with the value.
      *
-     * @returns The passed provider or its mock.
+     * @returns The value or undefined.
      */
-    map<T>(provider: Provider<T>): Provider<T>;
+    get(key: K): V | undefined;
     /**
-     * Registers a mock provider and retursns a new mock map with that mock.
+     * Sets a value under a key.
      *
-     * @param provider - An original provider.
-     * @param replacement - A provider that will be a mock of the first provider.
+     * @param key - The key that will be associated with the value.
+     * @param value - The value to set.
      *
-     * @returns A new mock map with added mock.
+     * @returns A modified immutable map with the value being set in it.
      */
-    add<T>(provider: Provider<T>, replacement: Provider<T>): MockMap;
+    set(key: K, value: V): ImmutableMap<K, V>;
     /**
-     * Applies mocks from another map to the current one and returns a new map.
-     * If there are identical keys (original providers),
-     * they will be overwritten by mocks from the other map.
+     * Merges two immutable maps. If there're any matching keys,
+     * values from the second map will override values from the first map.
      *
-     * @param otherMockMap - A mock map that will be applied.
+     * @param other The second immutable map.
      *
-     * @returns A new mock map with applied mocks.
+     * @returns A new immutable map as a result of merging two maps.
      */
-    apply(otherMockMap: MockMap): MockMap;
+    merge(other: ImmutableMap<K, V>): ImmutableMap<K, V>;
 };
+
+/**
+ * A map of providers to their compatible versions.
+ *
+ * Passed to a provider call in a resolution context object
+ * in order to replace providers with their mocks.
+ * ```ts
+ * const mocks = createMockMap().set(otherProvider, otherProviderMock)
+ * provider({ mocks })
+ * ```
+ */
+type MockMap = ImmutableMap<Provider<any>, Provider<any>>;
 /**
- * Creates a new mock map that stores and provides provider mocks.
+ * Creates a mock map instance.
  *
- * @param entries - Entries of a mock map.
+ * Passed to a provider call in a resolution context object
+ * in order to replace providers with their mocks.
+ * ```ts
+ * const mocks = createMockMap().set(otherProvider, otherProviderMock)
+ * provider({ mocks })
+ * ```
  *
- * @returns A new mock map.
+ * @returns The mock map instance.
  */
-declare const createMockMap: (entries?: MockMapEntries) => {
-    entries: MockMapEntries;
-    map: <T>(provider: Provider<T>) => Provider<T>;
-    add: <T>(provider: Provider<T>, replacement: Provider<T>) => MockMap;
-    apply: (otherMockMap: MockMap) => MockMap;
-};
+declare const createMockMap: () => MockMap;
 
 /**
- * Calls a resolver(factory) with an optional scope and a mock map
- * and returns an instance.
+ * A map of providers to their instances.
  *
- * A passed scope will be propagated up a graph and will be passed
- * to all scoped providers to resolve their instance within this scope.
- * If a provider is scoped, it will either create a new instance
- * and store it in the scope, or retrieve an already created instance
- * from the scope.
+ * Passed to a provider call in a resolution context object
+ * to resolve instances of scoped providers within it.
+ * ```ts
+ * const scope = createScope()
+ * provider({ scope })
+ * ```
+ */
+type Scope = Map<Provider<any>, any>;
+/**
+ * Creates a scope instance.
+ *
+ * Scope is passed to a provider call in a resolution context object
+ * to resolve instances of scoped providers within it.
+ * ```ts
+ * const scope = createScope()
+ * provider({ scope })
+ * ```
  *
- * It is also possible to explicitly pass a mock map, but It's not recommended.
- * If you want to mock(replace) providers for a resolution,
- * it's best to use `mock` method.
+ * @returns The scope instance.
  */
-type ProviderCallable<T> = (scope?: Scope, mockMap?: MockMap) => T;
+declare const createScope: () => Scope;
+
 /**
- * Instance factory with lifetime and dynamic context.
+ * A wrapper around the resolver for contextual dependency resolution.
+ *
+ * Resolves an instance by calling a resolver
+ * with a resolution context that will be propagated
+ * throughout a dependency tree.
+ *
+ * When passing a scope it will try to get an instance from it
+ * or create a new one and put it there.
+ *
+ * When passing mocks, it will try to get its own mock version,
+ * and if there is one, it will use it instead of itself.
+ */
+type Provider<T> = (context?: ResolutionContext) => T;
+/**
+ * A resolution lifetime.
+ *
+ * Passed when creating a provider to determine its behavior.
+ *
+ * `"transient"` doesn't provide any modifications to a resolver behaviour,
+ * so the resolver will create a new instance on each request.
+ *
+ * `"singleton"` forces the resolver to create an instance once
+ * and return it in subsequent requests.
+ *
+ * `"scoped"` forces the resolver to take its instance from a provided scope
+ * or create a new one and save it if there is none.
+ * If no scope is passed, it will create a new instance on each request.
  */
-type Provider<T> = ProviderCallable<T> & {
-    /**
-     * Mocks(replaces) a provider within the visible graph,
-     * returning a new provider with that mock.
-     *
-     * @param dependencyProvider A provider used by the current provider
-     * that needs to be replaced.
-     * @param replacement A provider with a same interface
-     * that will be a replacement for the first one.
-     *
-     * @returns A new provider with the mocked dependency provider.
-     */
-    mock<U>(dependencyProvider: Provider<U>, replacement: Provider<U>): Provider<T>;
-};
 type Lifetime = "transient" | "singleton" | "scoped";
 /**
- * A function that resolves an instance of a passed provider.
- * It's needed to resolve correct instance in a scope
- * and to use mock of the passed provider, if any.
+ * A function that creates an instance using a resolution context.
  */
-type UseFn = <T>(provider: Provider<T>) => T;
+type Resolver<T> = (context?: ResolutionContext) => T;
 /**
- * A function that creates an instance by resolving its dependencies.
- * If there are dependencies, you must use `use` function passed
- * in the first argument.
+ * An object that holds information about a scope and provider mocks.
+ *
+ * Passed to the provider call to resolve scope instances and mock providers.
  */
-type Resolver<T> = (use: UseFn) => T;
+type ResolutionContext = {
+    scope?: Scope;
+    mocks?: MockMap;
+};
 /**
- * Creates a new provider, instance factory with lifetime and dynamic context.
+ * Creates a provider instance,
+ * a wrapper around a resolver for contextual dependency resolution.
+ *
+ * @param lifetime
+ * A resolution lifetime.
+ *
+ * `"transient"` doesn't provide any modifications to a resolver behaviour,
+ * so the resolver will create a new instance on each request.
  *
- * @param lifetime - Instance lifetime.
+ * `"singleton"` forces the resolver to create an instance once
+ * and return it in subsequent requests.
  *
- * @param resolver - A function that creates an instance
- * by resolving its dependencies
- * If there are dependencies, you must use `use` function passed
- * in the first argument.
+ * `"scoped"` forces the resolver to take its resolution from a provided scope
+ * or create a new one and save it if there is none.
+ * If no scope is passed, it will create a new instance on each request.
  *
- * @param mockMap - An optional mock map. Not recommended to specify explicitly,
- * use `mock` method to mock providers.
+ * @param resolver
+ * The function that creates an instance using a resolution context.
  *
- * @returns A new provider.
+ * @returns The provider instance.
  */
-declare const provide: <T>(lifetime: Lifetime, resolver: Resolver<T>, mockMap?: MockMap) => Provider<T>;
+declare const provide: <T>(lifetime: Lifetime, resolver: Resolver<T>) => Provider<T>;
 /**
- * Creates a new transient provider.
- * This provider will return a new instance on each resolution.
+ * Creates a transient provider instance,
+ * a wrapper around a resolver for contextual dependency resolution
+ * that will create a new instance on each request.
  *
- * @param resolver - A function that creates an instance
- * by resolving its dependencies
- * If there are dependencies, you must use `use` function passed
- * in the first argument.
+ * @param resolver
+ * The function that creates an instance using a resolution context.
  *
- * @returns A new transient provider.
+ * @returns The transient provider instance.
  */
 declare const transient: <T>(resolver: Resolver<T>) => Provider<T>;
 /**
- * Creates a new singleton provider.
- * This provider will create an instance once and return it on every request.
+ * Creates a transient provider instance,
+ * a wrapper around a resolver for contextual dependency resolution
+ * that will create an instance once and return it in subsequent requests.
  *
- * @param resolver - A function that creates an instance
- * by resolving its dependencies
- * If there are dependencies, you must use `use` function passed
- * in the first argument.
+ * @param resolver
+ * The function that creates an instance using a resolution context.
  *
- * @returns A new singleton provider.
+ * @returns The singleton provider instance.
  */
 declare const singleton: <T>(resolver: Resolver<T>) => Provider<T>;
 /**
- * Creates a new transient provider.
- * This provider will save the instance in scope on first resolution
- * and will retrieve it from scope on next resolutions.
- * If scope was not specified, will create a new instance on each resolution.
+ * Creates a transient provider instance,
+ * a wrapper around a resolver for contextual dependency resolution
+ * that will take its resolution from a provided scope
+ * or create a new one and save it if there is none.
+ * If no scope is passed, it will create a new instance on each request.
  *
- * @param resolver - A function that creates an instance
- * by resolving its dependencies
- * If there are dependencies, you must use `use` function passed
- * in the first argument.
+ * @param resolver
+ * The function that creates an instance using a resolution context.
  *
- * @returns A new scoped provider.
+ * @returns The scoped provider instance.
  */
 declare const scoped: <T>(resolver: Resolver<T>) => Provider<T>;
 
-/**
- * A map of string keys to providers.
- */
-type ProviderMap = Record<string, Provider<any>>;
-type InferProviderMapOutputs<Providers extends ProviderMap> = {
+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;
 };
 /**
- * Resolves all providers in a `ProviderMap` and
- * returns an object containing their instances.
- *
- * @param scope - An optional scope to use for scoped providers.
- * @param mockMap - An optional mock map to use for mocking providers.
- *
- * @returns An object containing the resolved instances of the providers.
+ * Awaits all promises and wraps the collection in a promise
+ * if there'ss at least one `Promise` in the collection,
+ * otherwise returns an untouched type.
  */
-type ProviderSelectionCallable<Providers extends ProviderMap> = (scope?: Scope, mockMap?: MockMap) => InferProviderMapOutputs<Providers>;
+type AwaitAllValuesInCollection<T extends any[] | Record<any, any>> = Promise<any> extends T[keyof T] ? Promise<{
+    [I in keyof T]: T[I] extends Promise<infer T> ? T : T[I];
+}> : T;
 /**
- * A selection of providers.
+ * Calls every provider 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.
+ *
+ * @param providers - The list of providers.
+ * @param context - The resolution context.
  *
- * @property map - The `ProviderMap` that the selection is based on.
- * @property mock - A function that mocks a provider within the selection,
- * returning a new `ProviderSelection` with the mock applied.
+ * @returns The list of resolutions.
  */
-type ProviderSelection<Providers extends ProviderMap> = ProviderSelectionCallable<Providers> & {
-    /**
-     * The `ProviderMap` that the selection is based on.
-     */
-    map: Providers;
-    /**
-     * Mocks a provider within the selection, returning a new
-     * `ProviderSelection` with the mock applied.
-     *
-     * @param dependencyProvider - A provider used by the current provider
-     * that needs to be replaced.
-     * @param replacement - A provider with a same interface that will be
-     * a replacement for the first one.
-     *
-     * @returns A new `ProviderSelection` with the mocked provider.
-     */
-    mock<T>(dependencyProvider: Provider<T>, replacement: Provider<T>): ProviderSelection<Providers>;
-};
+declare const resolveList: <const Providers extends ProviderList>(providers: Providers, context?: ResolutionContext) => AwaitAllValuesInCollection<InferProviderCollectionResolutions<Providers>>;
 /**
- * Creates a new provider selection from a provider map.
+ * Calls every provider 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.
  *
- * @param map - A map of string keys to providers.
+ * @param providers - The map of providers.
+ * @param context - The resolution context.
  *
- * @returns A new provider selection.
+ * @returns The map of resolutions.
  */
-declare const select: <Providers extends ProviderMap>(map: Providers) => ProviderSelection<Providers>;
+declare const resolveMap: <const Providers extends ProviderRecord>(providers: Providers, context?: ResolutionContext) => AwaitAllValuesInCollection<InferProviderCollectionResolutions<Providers>>;
 
-export { type MockMap, type Provider, type ProviderSelection, type Scope, createMockMap, createScope, provide, scoped, select, singleton, transient };
+export { type Lifetime, type MockMap, type Provider, type ResolutionContext, type Resolver, type Scope, createMockMap, createScope, provide, resolveList, resolveMap, scoped, singleton, transient };

package/dist/index.js

@@ -22,8 +22,9 @@ __export(src_exports, {
   createMockMap: () => createMockMap,
   createScope: () => createScope,
   provide: () => provide,
+  resolveList: () => resolveList,
+  resolveMap: () => resolveMap,
   scoped: () => scoped,
-  select: () => select,
   singleton: () => singleton,
   transient: () => transient
 });
@@ -31,57 +32,29 @@ module.exports = __toCommonJS(src_exports);
 
 // src/helpers.ts
 var once = (fn) => {
-  let cachedResult;
-  return Object.assign(
-    (...args) => cachedResult ?? (cachedResult = fn(...args)),
-    fn
-  );
-};
-
-// src/mock-map.ts
-var createMockMap = (entries = []) => {
-  const map = (provider) => {
-    var _a;
-    return ((_a = entries.find((e) => e[0] === provider)) == null ? void 0 : _a[1]) || provider;
-  };
-  const add = (provider, replacement) => {
-    const newEntries = entries.map(
-      (e) => e[0] === provider ? [e[0], replacement] : e
-    );
-    if (newEntries.length === entries.length)
-      newEntries.push([provider, replacement]);
-    return createMockMap(newEntries);
-  };
-  const apply = (otherMockMap) => createMockMap([
-    ...entries.filter(
-      (e) => otherMockMap.entries.find((oe) => oe[0] === e[0]) === void 0
-    ),
-    ...otherMockMap.entries
-  ]);
-  return { entries, map, add, apply };
+  let returned = false;
+  let result;
+  return Object.assign((...args) => {
+    if (returned) return result;
+    result = fn(...args);
+    returned = true;
+    return result;
+  }, fn);
 };
 
 // src/provider.ts
-var provide = (lifetime, resolver, mockMap = createMockMap()) => {
-  const getSelf = once(() => Object.assign(resolve, properties));
-  const originalResolver = resolver;
+var provide = (lifetime, resolver) => {
+  const getSelf = once(() => resolve);
   resolver = lifetime === "singleton" ? once(resolver) : resolver;
-  const resolve = (scope, requestMockMap) => {
-    const currentMockMap = requestMockMap ? mockMap.apply(requestMockMap) : mockMap;
-    const use = (provider) => currentMockMap.map(provider)(scope, currentMockMap);
-    if (lifetime !== "scoped" || !scope) return resolver(use);
-    const resolution = scope.get(getSelf()) || resolver(use);
-    scope.set(getSelf(), resolution);
+  const resolve = (context) => {
+    var _a;
+    const maybeOwnMock = (_a = context == null ? void 0 : context.mocks) == null ? void 0 : _a.get(getSelf());
+    if (maybeOwnMock) return maybeOwnMock(context);
+    if (lifetime !== "scoped" || !(context == null ? void 0 : context.scope)) return resolver(context);
+    const resolution = context.scope.has(getSelf()) ? context.scope.get(getSelf()) : resolver(context);
+    context.scope.set(getSelf(), resolution);
     return resolution;
   };
-  const mock = (dependencyProvider, replacement) => provide(
-    lifetime,
-    originalResolver,
-    mockMap.add(dependencyProvider, replacement)
-  );
-  const properties = {
-    mock
-  };
   return getSelf();
 };
 var transient = (resolver) => provide("transient", resolver);
@@ -89,33 +62,74 @@ var singleton = (resolver) => provide("singleton", resolver);
 var scoped = (resolver) => provide("scoped", resolver);
 
 // src/scope.ts
-var createScope = () => /* @__PURE__ */ new WeakMap();
+var createScope = () => /* @__PURE__ */ new Map();
 
-// src/selection.ts
-var select = (map) => {
-  const resolveAll = (scope, mockMap) => {
-    const resultEntries = Object.entries(map).map(
-      ([key, provider]) => mockMap ? [key, mockMap.map(provider)(scope, mockMap)] : [key, provider(scope, mockMap)]
-    );
-    return Object.fromEntries(
-      resultEntries
-    );
+// src/readonly-map.ts
+var createImmutableMap = (entries = []) => {
+  const get = (key) => {
+    var _a;
+    return (_a = entries.find((entry) => entry[0] === key)) == null ? void 0 : _a[1];
+  };
+  const set = (key, value) => {
+    if (get(key) !== void 0) {
+      const newEntries2 = entries.map(
+        (entry) => entry[0] === key ? [entry[0], value] : entry
+      );
+      return createImmutableMap(newEntries2);
+    }
+    const newEntries = [...entries, [key, value]];
+    return createImmutableMap(newEntries);
   };
-  const mock = (dependencyProvider, replacement) => {
-    const newEntries = Object.entries(map).map(
-      ([key, provider]) => provider === dependencyProvider ? [key, replacement] : [key, provider.mock(dependencyProvider, replacement)]
-    );
-    return select(Object.fromEntries(newEntries));
+  const merge = (other) => {
+    const newEntries = [
+      ...entries.filter((entry) => other.get(entry[0]) === void 0),
+      ...other.entries
+    ];
+    return createImmutableMap(newEntries);
   };
-  return Object.assign(resolveAll, { map, mock });
+  return Object.freeze({
+    entries,
+    get,
+    set,
+    merge
+  });
+};
+
+// src/mock-map.ts
+var createMockMap = () => createImmutableMap();
+
+// src/collection-resolution.ts
+var resolveList = (providers, context) => {
+  const resolutions = providers.map((provider) => provider(context));
+  return resolutions.some((resolution) => resolution instanceof Promise) ? Promise.all(resolutions) : resolutions;
+};
+var resolveMap = (providers, context) => {
+  let resolutionMapEntries = Object.entries(providers).map(
+    ([key, provider]) => [key, provider(context)]
+  );
+  if (resolutionMapEntries.some(
+    ([, resolution]) => resolution instanceof Promise
+  )) {
+    return (async () => {
+      resolutionMapEntries = await Promise.all(
+        resolutionMapEntries.map(async ([key, resolution]) => [
+          key,
+          await resolution
+        ])
+      );
+      return Object.fromEntries(resolutionMapEntries);
+    })();
+  }
+  return Object.fromEntries(resolutionMapEntries);
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   createMockMap,
   createScope,
   provide,
+  resolveList,
+  resolveMap,
   scoped,
-  select,
   singleton,
   transient
 });

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/index.ts","../src/helpers.ts","../src/mock-map.ts","../src/provider.ts","../src/scope.ts","../src/selection.ts"],"sourcesContent":["export * from \"./provider\";\nexport * from \"./scope\";\nexport * from \"./selection\";\nexport * from \"./mock-map\";\n","/**\n * Creates a function that will invoke the provided function `fn` only once,\n * caching the result for subsequent calls with the same arguments.\n *\n * @param fn - The function to invoke once and cache the result.\n * @returns A new function that returns the cached result after the first call.\n */\nexport const once = <A extends any[], R>(fn: (...args: A) => R) => {\n    let cachedResult: R | undefined;\n\n    return Object.assign(\n        (...args: A) => cachedResult ?? (cachedResult = fn(...args)),\n        fn,\n    );\n};\n","import { Provider } from \"./provider\";\n\ntype MockMapEntries = [Provider<any>, Provider<any>][];\n\n/**\n * Stores and provides provider mocks.\n */\nexport type MockMap = {\n    entries: MockMapEntries;\n\n    /**\n     * Returns the provider's mock or the provider itself\n     * depending on the presence of the mock.\n     *\n     * @param provider - An original provider whose mock is needed to get.\n     *\n     * @returns The passed provider or its mock.\n     */\n    map<T>(provider: Provider<T>): Provider<T>;\n\n    /**\n     * Registers a mock provider and retursns a new mock map with that mock.\n     *\n     * @param provider - An original provider.\n     * @param replacement - A provider that will be a mock of the first provider.\n     *\n     * @returns A new mock map with added mock.\n     */\n    add<T>(provider: Provider<T>, replacement: Provider<T>): MockMap;\n\n    /**\n     * Applies mocks from another map to the current one and returns a new map.\n     * If there are identical keys (original providers),\n     * they will be overwritten by mocks from the other map.\n     *\n     * @param otherMockMap - A mock map that will be applied.\n     *\n     * @returns A new mock map with applied mocks.\n     */\n    apply(otherMockMap: MockMap): MockMap;\n};\n\n/**\n * Creates a new mock map that stores and provides provider mocks.\n *\n * @param entries - Entries of a mock map.\n *\n * @returns A new mock map.\n */\nexport const createMockMap = (entries: MockMapEntries = []) => {\n    const map: MockMap[\"map\"] = (provider) =>\n        entries.find((e) => e[0] === provider)?.[1] || provider;\n\n    const add: MockMap[\"add\"] = (provider, replacement) => {\n        const newEntries: MockMapEntries = entries.map((e) =>\n            e[0] === provider ? [e[0], replacement] : e,\n        );\n\n        if (newEntries.length === entries.length)\n            newEntries.push([provider, replacement]);\n\n        return createMockMap(newEntries);\n    };\n\n    const apply: MockMap[\"apply\"] = (otherMockMap) =>\n        createMockMap([\n            ...entries.filter(\n                (e) =>\n                    otherMockMap.entries.find((oe) => oe[0] === e[0]) ===\n                    undefined,\n            ),\n            ...otherMockMap.entries,\n        ]);\n\n    return { entries, map, add, apply };\n};\n","import { once } from \"./helpers\";\nimport { Scope } from \"./scope\";\nimport { createMockMap, MockMap } from \"./mock-map\";\n\n/**\n * Calls a resolver(factory) with an optional scope and a mock map\n * and returns an instance.\n *\n * A passed scope will be propagated up a graph and will be passed\n * to all scoped providers to resolve their instance within this scope.\n * If a provider is scoped, it will either create a new instance\n * and store it in the scope, or retrieve an already created instance\n * from the scope.\n *\n * It is also possible to explicitly pass a mock map, but It's not recommended.\n * If you want to mock(replace) providers for a resolution,\n * it's best to use `mock` method.\n */\ntype ProviderCallable<T> = (scope?: Scope, mockMap?: MockMap) => T;\n\n/**\n * Instance factory with lifetime and dynamic context.\n */\nexport type Provider<T> = ProviderCallable<T> & {\n    /**\n     * Mocks(replaces) a provider within the visible graph,\n     * returning a new provider with that mock.\n     *\n     * @param dependencyProvider A provider used by the current provider\n     * that needs to be replaced.\n     * @param replacement A provider with a same interface\n     * that will be a replacement for the first one.\n     *\n     * @returns A new provider with the mocked dependency provider.\n     */\n    mock<U>(\n        dependencyProvider: Provider<U>,\n        replacement: Provider<U>,\n    ): Provider<T>;\n};\n\ntype Lifetime = \"transient\" | \"singleton\" | \"scoped\";\n\n/**\n * A function that resolves an instance of a passed provider.\n * It's needed to resolve correct instance in a scope\n * and to use mock of the passed provider, if any.\n */\ntype UseFn = <T>(provider: Provider<T>) => T;\n\n/**\n * A function that creates an instance by resolving its dependencies.\n * If there are dependencies, you must use `use` function passed\n * in the first argument.\n */\ntype Resolver<T> = (use: UseFn) => T;\n\n/**\n * Creates a new provider, instance factory with lifetime and dynamic context.\n *\n * @param lifetime - Instance lifetime.\n *\n * @param resolver - A function that creates an instance\n * by resolving its dependencies\n * If there are dependencies, you must use `use` function passed\n * in the first argument.\n *\n * @param mockMap - An optional mock map. Not recommended to specify explicitly,\n * use `mock` method to mock providers.\n *\n * @returns A new provider.\n */\nexport const provide = <T>(\n    /**\n     * Instance lifetime. Can be `\"transient\"`, `\"singleton\"` or `\"scoped\"`.\n     *\n     * If `\"transient\"`, will return a new instance on each resolution.\n     *\n     * If `\"singleton\"`, will create an instance once and return it on every request.\n     *\n     * If `\"scoped\"`, will save the instance in scope on first resolution\n     * and will retrieve it from scope on next resolutions.\n     * If scope was not specified, will create a new instance on each resolution.\n     */\n    lifetime: Lifetime,\n\n    /**\n     * A function that creates an instance by resolving its dependencies.\n     * If there are dependencies, you must use `use` function passed\n     * in the first argument.\n     */\n    resolver: Resolver<T>,\n\n    /**\n     * An optional mock map. Not recommended to specify explicitly,\n     * use `mock` method to mock providers.\n     */\n    mockMap: MockMap = createMockMap(),\n): Provider<T> => {\n    type ProviderType = Provider<T>;\n\n    const getSelf = once(() => Object.assign(resolve, properties));\n\n    const originalResolver = resolver;\n    resolver = lifetime === \"singleton\" ? once(resolver) : resolver;\n\n    const resolve: ProviderCallable<T> = (scope, requestMockMap) => {\n        const currentMockMap = requestMockMap\n            ? mockMap.apply(requestMockMap)\n            : mockMap;\n\n        const use: UseFn = (provider) =>\n            currentMockMap.map(provider)(scope, currentMockMap);\n\n        if (lifetime !== \"scoped\" || !scope) return resolver(use);\n\n        const resolution = scope.get(getSelf()) || resolver(use);\n        scope.set(getSelf(), resolution);\n\n        return resolution;\n    };\n\n    const mock: ProviderType[\"mock\"] = (dependencyProvider, replacement) =>\n        provide(\n            lifetime,\n            originalResolver,\n            mockMap.add(dependencyProvider, replacement),\n        );\n\n    const properties = {\n        mock,\n    };\n\n    return getSelf();\n};\n\n/**\n * Creates a new transient provider.\n * This provider will return a new instance on each resolution.\n *\n * @param resolver - A function that creates an instance\n * by resolving its dependencies\n * If there are dependencies, you must use `use` function passed\n * in the first argument.\n *\n * @returns A new transient provider.\n */\nexport const transient = <T>(resolver: Resolver<T>) =>\n    provide(\"transient\", resolver);\n\n/**\n * Creates a new singleton provider.\n * This provider will create an instance once and return it on every request.\n *\n * @param resolver - A function that creates an instance\n * by resolving its dependencies\n * If there are dependencies, you must use `use` function passed\n * in the first argument.\n *\n * @returns A new singleton provider.\n */\nexport const singleton = <T>(resolver: Resolver<T>) =>\n    provide(\"singleton\", resolver);\n\n/**\n * Creates a new transient provider.\n * This provider will save the instance in scope on first resolution\n * and will retrieve it from scope on next resolutions.\n * If scope was not specified, will create a new instance on each resolution.\n *\n * @param resolver - A function that creates an instance\n * by resolving its dependencies\n * If there are dependencies, you must use `use` function passed\n * in the first argument.\n *\n * @returns A new scoped provider.\n */\nexport const scoped = <T>(resolver: Resolver<T>) => provide(\"scoped\", resolver);\n","import { Provider } from \"./provider\";\n\n/**\n * A map of providers to their instances.\n * Passed to the provider call to resolve instances\n * of scoped providers within it.\n */\nexport type Scope = WeakMap<Provider<any>, any>;\n\n/**\n * Creates a new scope, map of providers to their instances.\n * Scope is passed to the provider call to resolve instances\n * of scoped providers within it.\n *\n * @returns A new scope.\n */\nexport const createScope = (): Scope => new WeakMap();\n","import { Provider } from \"./provider\";\nimport { Scope } from \"./scope\";\nimport { MockMap } from \"./mock-map\";\n\n/**\n * A map of string keys to providers.\n */\ntype ProviderMap = Record<string, Provider<any>>;\n\ntype InferProviderMapOutputs<Providers extends ProviderMap> = {\n    [K in keyof Providers]: Providers[K] extends Provider<infer T> ? T : never;\n};\n\n/**\n * Resolves all providers in a `ProviderMap` and\n * returns an object containing their instances.\n *\n * @param scope - An optional scope to use for scoped providers.\n * @param mockMap - An optional mock map to use for mocking providers.\n *\n * @returns An object containing the resolved instances of the providers.\n */\ntype ProviderSelectionCallable<Providers extends ProviderMap> = (\n    scope?: Scope,\n    mockMap?: MockMap,\n) => InferProviderMapOutputs<Providers>;\n\n/**\n * A selection of providers.\n *\n * @property map - The `ProviderMap` that the selection is based on.\n * @property mock - A function that mocks a provider within the selection,\n * returning a new `ProviderSelection` with the mock applied.\n */\nexport type ProviderSelection<Providers extends ProviderMap> =\n    ProviderSelectionCallable<Providers> & {\n        /**\n         * The `ProviderMap` that the selection is based on.\n         */\n        map: Providers;\n        /**\n         * Mocks a provider within the selection, returning a new\n         * `ProviderSelection` with the mock applied.\n         *\n         * @param dependencyProvider - A provider used by the current provider\n         * that needs to be replaced.\n         * @param replacement - A provider with a same interface that will be\n         * a replacement for the first one.\n         *\n         * @returns A new `ProviderSelection` with the mocked provider.\n         */\n        mock<T>(\n            dependencyProvider: Provider<T>,\n            replacement: Provider<T>,\n        ): ProviderSelection<Providers>;\n    };\n\n/**\n * Creates a new provider selection from a provider map.\n *\n * @param map - A map of string keys to providers.\n *\n * @returns A new provider selection.\n */\nexport const select = <Providers extends ProviderMap>(\n    map: Providers,\n): ProviderSelection<Providers> => {\n    type SelectionType = ProviderSelection<Providers>;\n\n    const resolveAll: ProviderSelectionCallable<Providers> = (\n        scope,\n        mockMap,\n    ) => {\n        const resultEntries = Object.entries(map).map(([key, provider]) =>\n            mockMap\n                ? [key, mockMap.map(provider)(scope, mockMap)]\n                : [key, provider(scope, mockMap)],\n        );\n\n        return Object.fromEntries(\n            resultEntries,\n        ) as InferProviderMapOutputs<Providers>;\n    };\n\n    const mock: SelectionType[\"mock\"] = (dependencyProvider, replacement) => {\n        const newEntries = Object.entries(map).map(([key, provider]) =>\n            provider === dependencyProvider\n                ? [key, replacement]\n                : [key, provider.mock(dependencyProvider, replacement)],\n        );\n\n        return select(Object.fromEntries(newEntries) as Providers);\n    };\n\n    return Object.assign(resolveAll, { map, mock });\n};\n"],"mappings":"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","names":[]}
+{"version":3,"sources":["../src/index.ts","../src/helpers.ts","../src/provider.ts","../src/scope.ts","../src/readonly-map.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","/**\n * Creates a function that will invoke the provided function `fn` only once,\n * caching the result for subsequent calls with the same arguments.\n *\n * @returns A new function that returns the cached result after the first call.\n */\nexport const once = <A extends any[], R>(\n    /**\n     * The function to invoke once and cache the result.\n     */\n    fn: (...args: A) => R,\n) => {\n    let returned = false;\n    let result: R | undefined;\n\n    return Object.assign((...args: A): R => {\n        if (returned) return result!;\n\n        result = fn(...args);\n        returned = true;\n\n        return result;\n    }, fn);\n};\n","import { once } from \"./helpers\";\nimport { MockMap } from \"./mock-map\";\nimport { Scope } from \"./scope\";\n\n/**\n * A wrapper around the resolver for contextual dependency resolution.\n *\n * Resolves an instance by calling a resolver\n * with a resolution context that will be propagated\n * throughout a dependency tree.\n *\n * When passing a scope it will try to get an instance from it\n * or create a new one and put it there.\n *\n * When passing mocks, it will try to get its own mock version,\n * and if there is one, it will use it instead of itself.\n */\nexport type Provider<T> = (context?: ResolutionContext) => T;\n\n/**\n * A resolution lifetime.\n *\n * Passed when creating a provider to determine its behavior.\n *\n * `\"transient\"` doesn't provide any modifications to a resolver behaviour,\n * so the resolver will create a new instance on each request.\n *\n * `\"singleton\"` forces the resolver to create an instance once\n * and return it in subsequent requests.\n *\n * `\"scoped\"` forces the resolver to take its instance from a provided scope\n * or create a new one and save it if there is none.\n * If no scope is passed, it will create a new instance on each request.\n */\nexport type Lifetime = \"transient\" | \"singleton\" | \"scoped\";\n\n/**\n * A function that creates an instance using a resolution context.\n */\nexport type Resolver<T> = (context?: ResolutionContext) => T;\n\n/**\n * An object that holds information about a scope and provider mocks.\n *\n * Passed to the provider call to resolve scope instances and mock providers.\n */\nexport type ResolutionContext = {\n    scope?: Scope;\n    mocks?: MockMap;\n};\n\n/**\n * Creates a provider instance,\n * a wrapper around a resolver for contextual dependency resolution.\n *\n * @param lifetime\n * A resolution lifetime.\n *\n * `\"transient\"` doesn't provide any modifications to a resolver behaviour,\n * so the resolver will create a new instance on each request.\n *\n * `\"singleton\"` forces the resolver to create an instance once\n * and return it in subsequent requests.\n *\n * `\"scoped\"` forces the resolver to take its resolution from a provided scope\n * or create a new one and save it if there is none.\n * If no scope is passed, it will create a new instance on each request.\n *\n * @param resolver\n * The function that creates an instance using a resolution context.\n *\n * @returns The provider instance.\n */\nexport const provide = <T>(\n    lifetime: Lifetime,\n    resolver: Resolver<T>,\n): Provider<T> => {\n    const getSelf = once(() => resolve);\n\n    resolver = lifetime === \"singleton\" ? once(resolver) : resolver;\n\n    const resolve: Provider<T> = (context) => {\n        const maybeOwnMock = context?.mocks?.get(getSelf());\n        if (maybeOwnMock) return maybeOwnMock(context);\n\n        if (lifetime !== \"scoped\" || !context?.scope) return resolver(context);\n\n        const resolution = context.scope.has(getSelf())\n            ? context.scope.get(getSelf())\n            : resolver(context);\n        context.scope.set(getSelf(), resolution);\n\n        return resolution;\n    };\n\n    return getSelf();\n};\n\n/**\n * Creates a transient provider instance,\n * a wrapper around a resolver for contextual dependency resolution\n * that will create a new instance on each request.\n *\n * @param resolver\n * The function that creates an instance using a resolution context.\n *\n * @returns The transient provider instance.\n */\nexport const transient = <T>(resolver: Resolver<T>) =>\n    provide(\"transient\", resolver);\n\n/**\n * Creates a transient provider instance,\n * a wrapper around a resolver for contextual dependency resolution\n * that will create an instance once and return it in subsequent requests.\n *\n * @param resolver\n * The function that creates an instance using a resolution context.\n *\n * @returns The singleton provider instance.\n */\nexport const singleton = <T>(resolver: Resolver<T>) =>\n    provide(\"singleton\", resolver);\n\n/**\n * Creates a transient provider instance,\n * a wrapper around a resolver for contextual dependency resolution\n * that will take its resolution from a provided scope\n * or create a new one and save it if there is none.\n * If no scope is passed, it will create a new instance on each request.\n *\n * @param resolver\n * The function that creates an instance using a resolution context.\n *\n * @returns The scoped provider instance.\n */\nexport const scoped = <T>(resolver: Resolver<T>) => provide(\"scoped\", resolver);\n","import { Provider } from \"./provider\";\n\n/**\n * A map of providers to their instances.\n *\n * Passed to a provider call in a resolution context object\n * to resolve instances of scoped providers within it.\n * ```ts\n * const scope = createScope()\n * provider({ scope })\n * ```\n */\nexport type Scope = Map<Provider<any>, any>;\n\n/**\n * Creates a scope instance.\n *\n * Scope is passed to a provider call in a resolution context object\n * to resolve instances of scoped providers within it.\n * ```ts\n * const scope = createScope()\n * provider({ scope })\n * ```\n *\n * @returns The scope instance.\n */\nexport const createScope = (): Scope => new Map();\n","export type Entry<K, V> = [K, V];\nexport type Entries<K, V> = Entry<K, V>[];\n\n/**\n * An immutable map. It's similar to `Map`,\n * but with reduced functionality and readonly builder behavior.\n */\nexport type ImmutableMap<K, V> = {\n    /**\n     * Map's entries.\n     */\n    readonly entries: Entries<K, V>;\n\n    /**\n     * Retrieves a possibly existing value under a key.\n     *\n     * @param key - The key associated with the value.\n     *\n     * @returns The value or undefined.\n     */\n    get(key: K): V | undefined;\n\n    /**\n     * Sets a value under a key.\n     *\n     * @param key - The key that will be associated with the value.\n     * @param value - The value to set.\n     *\n     * @returns A modified immutable map with the value being set in it.\n     */\n    set(key: K, value: V): ImmutableMap<K, V>;\n\n    /**\n     * Merges two immutable maps. If there're any matching keys,\n     * values from the second map will override values from the first map.\n     *\n     * @param other The second immutable map.\n     *\n     * @returns A new immutable map as a result of merging two maps.\n     */\n    merge(other: ImmutableMap<K, V>): ImmutableMap<K, V>;\n};\n\n/**\n * Creates an immutable map. It's similar to `Map`,\n * but with reduced functionality and readonly builder behavior.\n *\n * @param entries - Map's entries.\n *\n * @returns The immutable map.\n */\nexport const createImmutableMap = <K, V>(\n    entries: Entries<K, V> = [],\n): ImmutableMap<K, V> => {\n    const get = (key: K) => entries.find((entry) => entry[0] === key)?.[1];\n\n    const set = (key: K, value: V) => {\n        if (get(key) !== undefined) {\n            const newEntries: Entries<K, V> = entries.map((entry) =>\n                entry[0] === key ? [entry[0], value] : entry,\n            );\n\n            return createImmutableMap(newEntries);\n        }\n\n        const newEntries: Entries<K, V> = [...entries, [key, value]];\n\n        return createImmutableMap(newEntries);\n    };\n\n    const merge = (other: ImmutableMap<K, V>) => {\n        const newEntries: Entries<K, V> = [\n            ...entries.filter((entry) => other.get(entry[0]) === undefined),\n            ...other.entries,\n        ];\n\n        return createImmutableMap(newEntries);\n    };\n\n    return Object.freeze({\n        entries,\n        get,\n        set,\n        merge,\n    });\n};\n","import { Provider } from \"./provider\";\nimport { createImmutableMap, ImmutableMap } from \"./readonly-map\";\n\n/**\n * A map of providers to their compatible versions.\n *\n * Passed to a provider call in a resolution context object\n * in order to replace providers with their mocks.\n * ```ts\n * const mocks = createMockMap().set(otherProvider, otherProviderMock)\n * provider({ mocks })\n * ```\n */\nexport type MockMap = ImmutableMap<Provider<any>, Provider<any>>;\n\n/**\n * Creates a mock map instance.\n *\n * Passed to a provider call in a resolution context object\n * in order to replace providers with their mocks.\n * ```ts\n * const mocks = createMockMap().set(otherProvider, otherProviderMock)\n * provider({ mocks })\n * ```\n *\n * @returns The mock map instance.\n */\nexport const createMockMap = (): MockMap => createImmutableMap();\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 AwaitAllValuesInCollection<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 * @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): AwaitAllValuesInCollection<\n    InferProviderCollectionResolutions<Providers>\n> => {\n    const resolutions = providers.map((provider) => provider(context));\n\n    return (\n        resolutions.some((resolution) => resolution instanceof Promise)\n            ? Promise.all(resolutions)\n            : resolutions\n    ) 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 * @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): AwaitAllValuesInCollection<\n    InferProviderCollectionResolutions<Providers>\n> => {\n    let resolutionMapEntries = Object.entries(providers).map(\n        ([key, provider]) => [key, provider(context)],\n    );\n\n    if (\n        resolutionMapEntries.some(\n            ([, resolution]) => resolution instanceof Promise,\n        )\n    ) {\n        return (async () => {\n            resolutionMapEntries = await Promise.all(\n                resolutionMapEntries.map(async ([key, resolution]) => [\n                    key,\n                    await resolution,\n                ]),\n            );\n\n            return Object.fromEntries(resolutionMapEntries);\n        })() as any;\n    }\n\n    return Object.fromEntries(resolutionMapEntries);\n};\n"],"mappings":"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","names":["newEntries"]}

package/dist/index.mjs

@@ -1,56 +1,28 @@
 // src/helpers.ts
 var once = (fn) => {
-  let cachedResult;
-  return Object.assign(
-    (...args) => cachedResult ?? (cachedResult = fn(...args)),
-    fn
-  );
-};
-
-// src/mock-map.ts
-var createMockMap = (entries = []) => {
-  const map = (provider) => {
-    var _a;
-    return ((_a = entries.find((e) => e[0] === provider)) == null ? void 0 : _a[1]) || provider;
-  };
-  const add = (provider, replacement) => {
-    const newEntries = entries.map(
-      (e) => e[0] === provider ? [e[0], replacement] : e
-    );
-    if (newEntries.length === entries.length)
-      newEntries.push([provider, replacement]);
-    return createMockMap(newEntries);
-  };
-  const apply = (otherMockMap) => createMockMap([
-    ...entries.filter(
-      (e) => otherMockMap.entries.find((oe) => oe[0] === e[0]) === void 0
-    ),
-    ...otherMockMap.entries
-  ]);
-  return { entries, map, add, apply };
+  let returned = false;
+  let result;
+  return Object.assign((...args) => {
+    if (returned) return result;
+    result = fn(...args);
+    returned = true;
+    return result;
+  }, fn);
 };
 
 // src/provider.ts
-var provide = (lifetime, resolver, mockMap = createMockMap()) => {
-  const getSelf = once(() => Object.assign(resolve, properties));
-  const originalResolver = resolver;
+var provide = (lifetime, resolver) => {
+  const getSelf = once(() => resolve);
   resolver = lifetime === "singleton" ? once(resolver) : resolver;
-  const resolve = (scope, requestMockMap) => {
-    const currentMockMap = requestMockMap ? mockMap.apply(requestMockMap) : mockMap;
-    const use = (provider) => currentMockMap.map(provider)(scope, currentMockMap);
-    if (lifetime !== "scoped" || !scope) return resolver(use);
-    const resolution = scope.get(getSelf()) || resolver(use);
-    scope.set(getSelf(), resolution);
+  const resolve = (context) => {
+    var _a;
+    const maybeOwnMock = (_a = context == null ? void 0 : context.mocks) == null ? void 0 : _a.get(getSelf());
+    if (maybeOwnMock) return maybeOwnMock(context);
+    if (lifetime !== "scoped" || !(context == null ? void 0 : context.scope)) return resolver(context);
+    const resolution = context.scope.has(getSelf()) ? context.scope.get(getSelf()) : resolver(context);
+    context.scope.set(getSelf(), resolution);
     return resolution;
   };
-  const mock = (dependencyProvider, replacement) => provide(
-    lifetime,
-    originalResolver,
-    mockMap.add(dependencyProvider, replacement)
-  );
-  const properties = {
-    mock
-  };
   return getSelf();
 };
 var transient = (resolver) => provide("transient", resolver);
@@ -58,32 +30,73 @@ var singleton = (resolver) => provide("singleton", resolver);
 var scoped = (resolver) => provide("scoped", resolver);
 
 // src/scope.ts
-var createScope = () => /* @__PURE__ */ new WeakMap();
+var createScope = () => /* @__PURE__ */ new Map();
 
-// src/selection.ts
-var select = (map) => {
-  const resolveAll = (scope, mockMap) => {
-    const resultEntries = Object.entries(map).map(
-      ([key, provider]) => mockMap ? [key, mockMap.map(provider)(scope, mockMap)] : [key, provider(scope, mockMap)]
-    );
-    return Object.fromEntries(
-      resultEntries
-    );
+// src/readonly-map.ts
+var createImmutableMap = (entries = []) => {
+  const get = (key) => {
+    var _a;
+    return (_a = entries.find((entry) => entry[0] === key)) == null ? void 0 : _a[1];
+  };
+  const set = (key, value) => {
+    if (get(key) !== void 0) {
+      const newEntries2 = entries.map(
+        (entry) => entry[0] === key ? [entry[0], value] : entry
+      );
+      return createImmutableMap(newEntries2);
+    }
+    const newEntries = [...entries, [key, value]];
+    return createImmutableMap(newEntries);
   };
-  const mock = (dependencyProvider, replacement) => {
-    const newEntries = Object.entries(map).map(
-      ([key, provider]) => provider === dependencyProvider ? [key, replacement] : [key, provider.mock(dependencyProvider, replacement)]
-    );
-    return select(Object.fromEntries(newEntries));
+  const merge = (other) => {
+    const newEntries = [
+      ...entries.filter((entry) => other.get(entry[0]) === void 0),
+      ...other.entries
+    ];
+    return createImmutableMap(newEntries);
   };
-  return Object.assign(resolveAll, { map, mock });
+  return Object.freeze({
+    entries,
+    get,
+    set,
+    merge
+  });
+};
+
+// src/mock-map.ts
+var createMockMap = () => createImmutableMap();
+
+// src/collection-resolution.ts
+var resolveList = (providers, context) => {
+  const resolutions = providers.map((provider) => provider(context));
+  return resolutions.some((resolution) => resolution instanceof Promise) ? Promise.all(resolutions) : resolutions;
+};
+var resolveMap = (providers, context) => {
+  let resolutionMapEntries = Object.entries(providers).map(
+    ([key, provider]) => [key, provider(context)]
+  );
+  if (resolutionMapEntries.some(
+    ([, resolution]) => resolution instanceof Promise
+  )) {
+    return (async () => {
+      resolutionMapEntries = await Promise.all(
+        resolutionMapEntries.map(async ([key, resolution]) => [
+          key,
+          await resolution
+        ])
+      );
+      return Object.fromEntries(resolutionMapEntries);
+    })();
+  }
+  return Object.fromEntries(resolutionMapEntries);
 };
 export {
   createMockMap,
   createScope,
   provide,
+  resolveList,
+  resolveMap,
   scoped,
-  select,
   singleton,
   transient
 };

package/dist/index.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/helpers.ts","../src/mock-map.ts","../src/provider.ts","../src/scope.ts","../src/selection.ts"],"sourcesContent":["/**\n * Creates a function that will invoke the provided function `fn` only once,\n * caching the result for subsequent calls with the same arguments.\n *\n * @param fn - The function to invoke once and cache the result.\n * @returns A new function that returns the cached result after the first call.\n */\nexport const once = <A extends any[], R>(fn: (...args: A) => R) => {\n    let cachedResult: R | undefined;\n\n    return Object.assign(\n        (...args: A) => cachedResult ?? (cachedResult = fn(...args)),\n        fn,\n    );\n};\n","import { Provider } from \"./provider\";\n\ntype MockMapEntries = [Provider<any>, Provider<any>][];\n\n/**\n * Stores and provides provider mocks.\n */\nexport type MockMap = {\n    entries: MockMapEntries;\n\n    /**\n     * Returns the provider's mock or the provider itself\n     * depending on the presence of the mock.\n     *\n     * @param provider - An original provider whose mock is needed to get.\n     *\n     * @returns The passed provider or its mock.\n     */\n    map<T>(provider: Provider<T>): Provider<T>;\n\n    /**\n     * Registers a mock provider and retursns a new mock map with that mock.\n     *\n     * @param provider - An original provider.\n     * @param replacement - A provider that will be a mock of the first provider.\n     *\n     * @returns A new mock map with added mock.\n     */\n    add<T>(provider: Provider<T>, replacement: Provider<T>): MockMap;\n\n    /**\n     * Applies mocks from another map to the current one and returns a new map.\n     * If there are identical keys (original providers),\n     * they will be overwritten by mocks from the other map.\n     *\n     * @param otherMockMap - A mock map that will be applied.\n     *\n     * @returns A new mock map with applied mocks.\n     */\n    apply(otherMockMap: MockMap): MockMap;\n};\n\n/**\n * Creates a new mock map that stores and provides provider mocks.\n *\n * @param entries - Entries of a mock map.\n *\n * @returns A new mock map.\n */\nexport const createMockMap = (entries: MockMapEntries = []) => {\n    const map: MockMap[\"map\"] = (provider) =>\n        entries.find((e) => e[0] === provider)?.[1] || provider;\n\n    const add: MockMap[\"add\"] = (provider, replacement) => {\n        const newEntries: MockMapEntries = entries.map((e) =>\n            e[0] === provider ? [e[0], replacement] : e,\n        );\n\n        if (newEntries.length === entries.length)\n            newEntries.push([provider, replacement]);\n\n        return createMockMap(newEntries);\n    };\n\n    const apply: MockMap[\"apply\"] = (otherMockMap) =>\n        createMockMap([\n            ...entries.filter(\n                (e) =>\n                    otherMockMap.entries.find((oe) => oe[0] === e[0]) ===\n                    undefined,\n            ),\n            ...otherMockMap.entries,\n        ]);\n\n    return { entries, map, add, apply };\n};\n","import { once } from \"./helpers\";\nimport { Scope } from \"./scope\";\nimport { createMockMap, MockMap } from \"./mock-map\";\n\n/**\n * Calls a resolver(factory) with an optional scope and a mock map\n * and returns an instance.\n *\n * A passed scope will be propagated up a graph and will be passed\n * to all scoped providers to resolve their instance within this scope.\n * If a provider is scoped, it will either create a new instance\n * and store it in the scope, or retrieve an already created instance\n * from the scope.\n *\n * It is also possible to explicitly pass a mock map, but It's not recommended.\n * If you want to mock(replace) providers for a resolution,\n * it's best to use `mock` method.\n */\ntype ProviderCallable<T> = (scope?: Scope, mockMap?: MockMap) => T;\n\n/**\n * Instance factory with lifetime and dynamic context.\n */\nexport type Provider<T> = ProviderCallable<T> & {\n    /**\n     * Mocks(replaces) a provider within the visible graph,\n     * returning a new provider with that mock.\n     *\n     * @param dependencyProvider A provider used by the current provider\n     * that needs to be replaced.\n     * @param replacement A provider with a same interface\n     * that will be a replacement for the first one.\n     *\n     * @returns A new provider with the mocked dependency provider.\n     */\n    mock<U>(\n        dependencyProvider: Provider<U>,\n        replacement: Provider<U>,\n    ): Provider<T>;\n};\n\ntype Lifetime = \"transient\" | \"singleton\" | \"scoped\";\n\n/**\n * A function that resolves an instance of a passed provider.\n * It's needed to resolve correct instance in a scope\n * and to use mock of the passed provider, if any.\n */\ntype UseFn = <T>(provider: Provider<T>) => T;\n\n/**\n * A function that creates an instance by resolving its dependencies.\n * If there are dependencies, you must use `use` function passed\n * in the first argument.\n */\ntype Resolver<T> = (use: UseFn) => T;\n\n/**\n * Creates a new provider, instance factory with lifetime and dynamic context.\n *\n * @param lifetime - Instance lifetime.\n *\n * @param resolver - A function that creates an instance\n * by resolving its dependencies\n * If there are dependencies, you must use `use` function passed\n * in the first argument.\n *\n * @param mockMap - An optional mock map. Not recommended to specify explicitly,\n * use `mock` method to mock providers.\n *\n * @returns A new provider.\n */\nexport const provide = <T>(\n    /**\n     * Instance lifetime. Can be `\"transient\"`, `\"singleton\"` or `\"scoped\"`.\n     *\n     * If `\"transient\"`, will return a new instance on each resolution.\n     *\n     * If `\"singleton\"`, will create an instance once and return it on every request.\n     *\n     * If `\"scoped\"`, will save the instance in scope on first resolution\n     * and will retrieve it from scope on next resolutions.\n     * If scope was not specified, will create a new instance on each resolution.\n     */\n    lifetime: Lifetime,\n\n    /**\n     * A function that creates an instance by resolving its dependencies.\n     * If there are dependencies, you must use `use` function passed\n     * in the first argument.\n     */\n    resolver: Resolver<T>,\n\n    /**\n     * An optional mock map. Not recommended to specify explicitly,\n     * use `mock` method to mock providers.\n     */\n    mockMap: MockMap = createMockMap(),\n): Provider<T> => {\n    type ProviderType = Provider<T>;\n\n    const getSelf = once(() => Object.assign(resolve, properties));\n\n    const originalResolver = resolver;\n    resolver = lifetime === \"singleton\" ? once(resolver) : resolver;\n\n    const resolve: ProviderCallable<T> = (scope, requestMockMap) => {\n        const currentMockMap = requestMockMap\n            ? mockMap.apply(requestMockMap)\n            : mockMap;\n\n        const use: UseFn = (provider) =>\n            currentMockMap.map(provider)(scope, currentMockMap);\n\n        if (lifetime !== \"scoped\" || !scope) return resolver(use);\n\n        const resolution = scope.get(getSelf()) || resolver(use);\n        scope.set(getSelf(), resolution);\n\n        return resolution;\n    };\n\n    const mock: ProviderType[\"mock\"] = (dependencyProvider, replacement) =>\n        provide(\n            lifetime,\n            originalResolver,\n            mockMap.add(dependencyProvider, replacement),\n        );\n\n    const properties = {\n        mock,\n    };\n\n    return getSelf();\n};\n\n/**\n * Creates a new transient provider.\n * This provider will return a new instance on each resolution.\n *\n * @param resolver - A function that creates an instance\n * by resolving its dependencies\n * If there are dependencies, you must use `use` function passed\n * in the first argument.\n *\n * @returns A new transient provider.\n */\nexport const transient = <T>(resolver: Resolver<T>) =>\n    provide(\"transient\", resolver);\n\n/**\n * Creates a new singleton provider.\n * This provider will create an instance once and return it on every request.\n *\n * @param resolver - A function that creates an instance\n * by resolving its dependencies\n * If there are dependencies, you must use `use` function passed\n * in the first argument.\n *\n * @returns A new singleton provider.\n */\nexport const singleton = <T>(resolver: Resolver<T>) =>\n    provide(\"singleton\", resolver);\n\n/**\n * Creates a new transient provider.\n * This provider will save the instance in scope on first resolution\n * and will retrieve it from scope on next resolutions.\n * If scope was not specified, will create a new instance on each resolution.\n *\n * @param resolver - A function that creates an instance\n * by resolving its dependencies\n * If there are dependencies, you must use `use` function passed\n * in the first argument.\n *\n * @returns A new scoped provider.\n */\nexport const scoped = <T>(resolver: Resolver<T>) => provide(\"scoped\", resolver);\n","import { Provider } from \"./provider\";\n\n/**\n * A map of providers to their instances.\n * Passed to the provider call to resolve instances\n * of scoped providers within it.\n */\nexport type Scope = WeakMap<Provider<any>, any>;\n\n/**\n * Creates a new scope, map of providers to their instances.\n * Scope is passed to the provider call to resolve instances\n * of scoped providers within it.\n *\n * @returns A new scope.\n */\nexport const createScope = (): Scope => new WeakMap();\n","import { Provider } from \"./provider\";\nimport { Scope } from \"./scope\";\nimport { MockMap } from \"./mock-map\";\n\n/**\n * A map of string keys to providers.\n */\ntype ProviderMap = Record<string, Provider<any>>;\n\ntype InferProviderMapOutputs<Providers extends ProviderMap> = {\n    [K in keyof Providers]: Providers[K] extends Provider<infer T> ? T : never;\n};\n\n/**\n * Resolves all providers in a `ProviderMap` and\n * returns an object containing their instances.\n *\n * @param scope - An optional scope to use for scoped providers.\n * @param mockMap - An optional mock map to use for mocking providers.\n *\n * @returns An object containing the resolved instances of the providers.\n */\ntype ProviderSelectionCallable<Providers extends ProviderMap> = (\n    scope?: Scope,\n    mockMap?: MockMap,\n) => InferProviderMapOutputs<Providers>;\n\n/**\n * A selection of providers.\n *\n * @property map - The `ProviderMap` that the selection is based on.\n * @property mock - A function that mocks a provider within the selection,\n * returning a new `ProviderSelection` with the mock applied.\n */\nexport type ProviderSelection<Providers extends ProviderMap> =\n    ProviderSelectionCallable<Providers> & {\n        /**\n         * The `ProviderMap` that the selection is based on.\n         */\n        map: Providers;\n        /**\n         * Mocks a provider within the selection, returning a new\n         * `ProviderSelection` with the mock applied.\n         *\n         * @param dependencyProvider - A provider used by the current provider\n         * that needs to be replaced.\n         * @param replacement - A provider with a same interface that will be\n         * a replacement for the first one.\n         *\n         * @returns A new `ProviderSelection` with the mocked provider.\n         */\n        mock<T>(\n            dependencyProvider: Provider<T>,\n            replacement: Provider<T>,\n        ): ProviderSelection<Providers>;\n    };\n\n/**\n * Creates a new provider selection from a provider map.\n *\n * @param map - A map of string keys to providers.\n *\n * @returns A new provider selection.\n */\nexport const select = <Providers extends ProviderMap>(\n    map: Providers,\n): ProviderSelection<Providers> => {\n    type SelectionType = ProviderSelection<Providers>;\n\n    const resolveAll: ProviderSelectionCallable<Providers> = (\n        scope,\n        mockMap,\n    ) => {\n        const resultEntries = Object.entries(map).map(([key, provider]) =>\n            mockMap\n                ? [key, mockMap.map(provider)(scope, mockMap)]\n                : [key, provider(scope, mockMap)],\n        );\n\n        return Object.fromEntries(\n            resultEntries,\n        ) as InferProviderMapOutputs<Providers>;\n    };\n\n    const mock: SelectionType[\"mock\"] = (dependencyProvider, replacement) => {\n        const newEntries = Object.entries(map).map(([key, provider]) =>\n            provider === dependencyProvider\n                ? [key, replacement]\n                : [key, provider.mock(dependencyProvider, replacement)],\n        );\n\n        return select(Object.fromEntries(newEntries) as Providers);\n    };\n\n    return Object.assign(resolveAll, { map, mock });\n};\n"],"mappings":"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","names":[]}
+{"version":3,"sources":["../src/helpers.ts","../src/provider.ts","../src/scope.ts","../src/readonly-map.ts","../src/mock-map.ts","../src/collection-resolution.ts"],"sourcesContent":["/**\n * Creates a function that will invoke the provided function `fn` only once,\n * caching the result for subsequent calls with the same arguments.\n *\n * @returns A new function that returns the cached result after the first call.\n */\nexport const once = <A extends any[], R>(\n    /**\n     * The function to invoke once and cache the result.\n     */\n    fn: (...args: A) => R,\n) => {\n    let returned = false;\n    let result: R | undefined;\n\n    return Object.assign((...args: A): R => {\n        if (returned) return result!;\n\n        result = fn(...args);\n        returned = true;\n\n        return result;\n    }, fn);\n};\n","import { once } from \"./helpers\";\nimport { MockMap } from \"./mock-map\";\nimport { Scope } from \"./scope\";\n\n/**\n * A wrapper around the resolver for contextual dependency resolution.\n *\n * Resolves an instance by calling a resolver\n * with a resolution context that will be propagated\n * throughout a dependency tree.\n *\n * When passing a scope it will try to get an instance from it\n * or create a new one and put it there.\n *\n * When passing mocks, it will try to get its own mock version,\n * and if there is one, it will use it instead of itself.\n */\nexport type Provider<T> = (context?: ResolutionContext) => T;\n\n/**\n * A resolution lifetime.\n *\n * Passed when creating a provider to determine its behavior.\n *\n * `\"transient\"` doesn't provide any modifications to a resolver behaviour,\n * so the resolver will create a new instance on each request.\n *\n * `\"singleton\"` forces the resolver to create an instance once\n * and return it in subsequent requests.\n *\n * `\"scoped\"` forces the resolver to take its instance from a provided scope\n * or create a new one and save it if there is none.\n * If no scope is passed, it will create a new instance on each request.\n */\nexport type Lifetime = \"transient\" | \"singleton\" | \"scoped\";\n\n/**\n * A function that creates an instance using a resolution context.\n */\nexport type Resolver<T> = (context?: ResolutionContext) => T;\n\n/**\n * An object that holds information about a scope and provider mocks.\n *\n * Passed to the provider call to resolve scope instances and mock providers.\n */\nexport type ResolutionContext = {\n    scope?: Scope;\n    mocks?: MockMap;\n};\n\n/**\n * Creates a provider instance,\n * a wrapper around a resolver for contextual dependency resolution.\n *\n * @param lifetime\n * A resolution lifetime.\n *\n * `\"transient\"` doesn't provide any modifications to a resolver behaviour,\n * so the resolver will create a new instance on each request.\n *\n * `\"singleton\"` forces the resolver to create an instance once\n * and return it in subsequent requests.\n *\n * `\"scoped\"` forces the resolver to take its resolution from a provided scope\n * or create a new one and save it if there is none.\n * If no scope is passed, it will create a new instance on each request.\n *\n * @param resolver\n * The function that creates an instance using a resolution context.\n *\n * @returns The provider instance.\n */\nexport const provide = <T>(\n    lifetime: Lifetime,\n    resolver: Resolver<T>,\n): Provider<T> => {\n    const getSelf = once(() => resolve);\n\n    resolver = lifetime === \"singleton\" ? once(resolver) : resolver;\n\n    const resolve: Provider<T> = (context) => {\n        const maybeOwnMock = context?.mocks?.get(getSelf());\n        if (maybeOwnMock) return maybeOwnMock(context);\n\n        if (lifetime !== \"scoped\" || !context?.scope) return resolver(context);\n\n        const resolution = context.scope.has(getSelf())\n            ? context.scope.get(getSelf())\n            : resolver(context);\n        context.scope.set(getSelf(), resolution);\n\n        return resolution;\n    };\n\n    return getSelf();\n};\n\n/**\n * Creates a transient provider instance,\n * a wrapper around a resolver for contextual dependency resolution\n * that will create a new instance on each request.\n *\n * @param resolver\n * The function that creates an instance using a resolution context.\n *\n * @returns The transient provider instance.\n */\nexport const transient = <T>(resolver: Resolver<T>) =>\n    provide(\"transient\", resolver);\n\n/**\n * Creates a transient provider instance,\n * a wrapper around a resolver for contextual dependency resolution\n * that will create an instance once and return it in subsequent requests.\n *\n * @param resolver\n * The function that creates an instance using a resolution context.\n *\n * @returns The singleton provider instance.\n */\nexport const singleton = <T>(resolver: Resolver<T>) =>\n    provide(\"singleton\", resolver);\n\n/**\n * Creates a transient provider instance,\n * a wrapper around a resolver for contextual dependency resolution\n * that will take its resolution from a provided scope\n * or create a new one and save it if there is none.\n * If no scope is passed, it will create a new instance on each request.\n *\n * @param resolver\n * The function that creates an instance using a resolution context.\n *\n * @returns The scoped provider instance.\n */\nexport const scoped = <T>(resolver: Resolver<T>) => provide(\"scoped\", resolver);\n","import { Provider } from \"./provider\";\n\n/**\n * A map of providers to their instances.\n *\n * Passed to a provider call in a resolution context object\n * to resolve instances of scoped providers within it.\n * ```ts\n * const scope = createScope()\n * provider({ scope })\n * ```\n */\nexport type Scope = Map<Provider<any>, any>;\n\n/**\n * Creates a scope instance.\n *\n * Scope is passed to a provider call in a resolution context object\n * to resolve instances of scoped providers within it.\n * ```ts\n * const scope = createScope()\n * provider({ scope })\n * ```\n *\n * @returns The scope instance.\n */\nexport const createScope = (): Scope => new Map();\n","export type Entry<K, V> = [K, V];\nexport type Entries<K, V> = Entry<K, V>[];\n\n/**\n * An immutable map. It's similar to `Map`,\n * but with reduced functionality and readonly builder behavior.\n */\nexport type ImmutableMap<K, V> = {\n    /**\n     * Map's entries.\n     */\n    readonly entries: Entries<K, V>;\n\n    /**\n     * Retrieves a possibly existing value under a key.\n     *\n     * @param key - The key associated with the value.\n     *\n     * @returns The value or undefined.\n     */\n    get(key: K): V | undefined;\n\n    /**\n     * Sets a value under a key.\n     *\n     * @param key - The key that will be associated with the value.\n     * @param value - The value to set.\n     *\n     * @returns A modified immutable map with the value being set in it.\n     */\n    set(key: K, value: V): ImmutableMap<K, V>;\n\n    /**\n     * Merges two immutable maps. If there're any matching keys,\n     * values from the second map will override values from the first map.\n     *\n     * @param other The second immutable map.\n     *\n     * @returns A new immutable map as a result of merging two maps.\n     */\n    merge(other: ImmutableMap<K, V>): ImmutableMap<K, V>;\n};\n\n/**\n * Creates an immutable map. It's similar to `Map`,\n * but with reduced functionality and readonly builder behavior.\n *\n * @param entries - Map's entries.\n *\n * @returns The immutable map.\n */\nexport const createImmutableMap = <K, V>(\n    entries: Entries<K, V> = [],\n): ImmutableMap<K, V> => {\n    const get = (key: K) => entries.find((entry) => entry[0] === key)?.[1];\n\n    const set = (key: K, value: V) => {\n        if (get(key) !== undefined) {\n            const newEntries: Entries<K, V> = entries.map((entry) =>\n                entry[0] === key ? [entry[0], value] : entry,\n            );\n\n            return createImmutableMap(newEntries);\n        }\n\n        const newEntries: Entries<K, V> = [...entries, [key, value]];\n\n        return createImmutableMap(newEntries);\n    };\n\n    const merge = (other: ImmutableMap<K, V>) => {\n        const newEntries: Entries<K, V> = [\n            ...entries.filter((entry) => other.get(entry[0]) === undefined),\n            ...other.entries,\n        ];\n\n        return createImmutableMap(newEntries);\n    };\n\n    return Object.freeze({\n        entries,\n        get,\n        set,\n        merge,\n    });\n};\n","import { Provider } from \"./provider\";\nimport { createImmutableMap, ImmutableMap } from \"./readonly-map\";\n\n/**\n * A map of providers to their compatible versions.\n *\n * Passed to a provider call in a resolution context object\n * in order to replace providers with their mocks.\n * ```ts\n * const mocks = createMockMap().set(otherProvider, otherProviderMock)\n * provider({ mocks })\n * ```\n */\nexport type MockMap = ImmutableMap<Provider<any>, Provider<any>>;\n\n/**\n * Creates a mock map instance.\n *\n * Passed to a provider call in a resolution context object\n * in order to replace providers with their mocks.\n * ```ts\n * const mocks = createMockMap().set(otherProvider, otherProviderMock)\n * provider({ mocks })\n * ```\n *\n * @returns The mock map instance.\n */\nexport const createMockMap = (): MockMap => createImmutableMap();\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 AwaitAllValuesInCollection<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 * @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): AwaitAllValuesInCollection<\n    InferProviderCollectionResolutions<Providers>\n> => {\n    const resolutions = providers.map((provider) => provider(context));\n\n    return (\n        resolutions.some((resolution) => resolution instanceof Promise)\n            ? Promise.all(resolutions)\n            : resolutions\n    ) 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 * @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): AwaitAllValuesInCollection<\n    InferProviderCollectionResolutions<Providers>\n> => {\n    let resolutionMapEntries = Object.entries(providers).map(\n        ([key, provider]) => [key, provider(context)],\n    );\n\n    if (\n        resolutionMapEntries.some(\n            ([, resolution]) => resolution instanceof Promise,\n        )\n    ) {\n        return (async () => {\n            resolutionMapEntries = await Promise.all(\n                resolutionMapEntries.map(async ([key, resolution]) => [\n                    key,\n                    await resolution,\n                ]),\n            );\n\n            return Object.fromEntries(resolutionMapEntries);\n        })() as any;\n    }\n\n    return Object.fromEntries(resolutionMapEntries);\n};\n"],"mappings":"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","names":["newEntries"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "atomic-di",
-  "version": "0.7.1-beta.1",
+  "version": "0.8.0-beta.1",
   "description": "A toolset for containerless dependency injection.",
   "repository": {
     "type": "git",