atomic-di 0.9.1-beta.3 → 1.0.0-rc.1

package/dist/index.d.ts

@@ -1,185 +1,139 @@
 /**
- * A map of providers to providers of the same type.
- * Lifetime is not a part of `Provider` type, so you can use
- * a different one if necessary.
- *
- * Passed to a provider call in a resolution context object
+ * A `Map` of providers to providers of the same type
+ * which is then passed to a provider call in a resolution context object
  * in order to replace providers with their mocks.
- * ```ts
- * const otherProvider =
- *     transitive(() => ...)
- * const otherProviderMock: typeof otherProvider =
- *     scoped(() => ...)
- *
- * const mocks = createMockMap()
- * mocks.set(otherProvider, otherProviderMock)
- *
- * provider({ mocks })
- * ```
  */
-type MockMap = Omit<Map<Provider<any>, Provider<any>>, "set" | "get"> & {
+type MockMap = Omit<Map<Resolver<any>, Resolver<any>>, "set" | "get"> & {
     /**
      * Sets a mock for a provider.
      *
      * @param provider - The original provider.
      * @param mock - The mock provider.
      */
-    set<T>(provider: Provider<T>, mock: Provider<T>): MockMap;
+    set<T>(provider: Resolver<T>, mock: Resolver<T>): MockMap;
     /**
      * Retrieves a mock of a provider. Returns undefined if there's none.
      *
      * @param provider - The provider.
      */
-    get<T>(provider: Provider<T>): Provider<T> | undefined;
+    get<T>(provider: Resolver<T>): Resolver<T> | undefined;
 };
 /**
- * Creates a mock map instance,
- * a map of providers to providers of the same type.
- * Lifetime is not a part of `Provider` type, so you can use
- * a different one if necessary.
- *
- * Passed to a provider call in a resolution context object
+ * Creates a `Map` of providers to providers of the same type
+ * which is then passed to a provider call in a resolution context object
  * in order to replace providers with their mocks.
- * ```ts
- * const otherProvider =
- *     transitive(() => ...)
- * const otherProviderMock: typeof otherProvider =
- *     scoped(() => ...)
  *
+ * @example
+ * ```ts
  * const mocks = createMockMap()
- * mocks.set(otherProvider, otherProviderMock)
+ *     .set(getConfig, getTestConfig)
  *
- * provider({ mocks })
+ * getThing({ mocks })
  * ```
  *
- * @returns The mock map instance.
+ * @returns The map instance.
  */
 declare const createMockMap: () => MockMap;
 
 /**
- * A map of providers to their instances.
- *
- * Passed to a provider call in a resolution context object
+ * A `Map` of providers to their instances
+ * that is then passed to a provider call in a resolution context object
  * to resolve instances of scoped providers within it.
- * ```ts
- * const scope = createScope()
- * provider({ scope })
- * ```
  */
-type Scope = Map<Provider<any>, any>;
+type Scope = Map<Resolver<any>, any>;
 /**
- * Creates a scope instance.
- *
- * Scope is passed to a provider call in a resolution context object
+ * Creates a `Map` of providers to their instances
+ * that is then passed to a provider call in a resolution context object
  * to resolve instances of scoped providers within it.
+ *
+ * @example
  * ```ts
- * const scope = createScope()
- * provider({ scope })
+ * const requestScope = createScope()
+ *
+ * app.use(() => {
+ *     const db = getDb({ scope: requestScope })
+ *     // ...
+ * })
  * ```
  *
- * @returns The scope instance.
+ * @returns The map instance.
  */
 declare const createScope: () => Scope;
 
 /**
- * A wrapper around the resolver(factory) 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.
+ * A function that returns a value of a particular type
+ * with a resolution context being passed to it.
  */
-type Lifetime = "transient" | "singleton" | "scoped";
+type Resolver<T> = (context?: ResolutionContext) => T;
 /**
- * A function that creates an instance using a resolution context.
+ * A function that resolves an instance or a `Promise` of a particular type
+ * based on a resolution context passed to it.
  */
-type Resolver<T> = (context?: ResolutionContext) => T;
+type Provider<T> = Resolver<T>;
 /**
- * An object that holds information about a scope and provider mocks.
- *
- * Passed to the provider call to resolve scope instances and mock providers.
+ * A context used by providers to resolve instances
+ * based on current scope and mocks.
  */
 type ResolutionContext = {
     scope?: Scope;
     mocks?: MockMap;
 };
 /**
- * Creates a provider instance,
- * a wrapper around a resolver(factory) 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.
+ * Creates a transient provider that will resolve a new instance on each call.
  *
- * `"singleton"` forces the resolver to create an instance once
- * and return it in subsequent requests.
- *
- * `"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 resolver
- * The function that creates an instance using a resolution context.
- *
- * @returns The provider instance.
- */
-declare const provide: <T>(lifetime: Lifetime, resolver: Resolver<T>) => Provider<T>;
-/**
- * Creates a transient provider instance,
- * a wrapper around a resolver(factory) for contextual dependency resolution
- * that will create a new instance on each request.
+ * @example
+ * ```ts
+ * const getThing = transient(() => createThing())
+ * getThing() !== getThing()
+ * ```
  *
  * @param resolver
- * The function that creates an instance using a resolution context.
+ * A function that returns a value of a particular type
+ * with a resolution context being passed to it.
  *
- * @returns The transient provider instance.
+ * @returns The transient provider.
  */
 declare const transient: <T>(resolver: Resolver<T>) => Provider<T>;
 /**
- * Creates a transient provider instance,
- * a wrapper around a resolver(factory) for contextual dependency resolution
- * that will create an instance once and return it in subsequent requests.
+ * Creates a singleton provider that will resolve an instance once
+ * and return it on every call.
+ *
+ * @example
+ * ```ts
+ * const getThing = singleton(() => createThing())
+ * getThing() === getThing()
+ * ```
  *
  * @param resolver
- * The function that creates an instance using a resolution context.
+ * A function that returns a value of a particular type
+ * with a resolution context being passed to it.
  *
- * @returns The singleton provider instance.
+ * @returns The singleton provider.
  */
 declare const singleton: <T>(resolver: Resolver<T>) => Provider<T>;
 /**
- * Creates a transient provider instance,
- * a wrapper around a resolver(factory) for contextual dependency resolution
- * that will take its resolution from a provided scope
+ * Creates a scoped provider that will take its resolution from a passed scope
  * or create a new one and save it if there is none.
- * If no scope is passed, it will create a new instance on each request.
+ * If no scope is passed, it will create a new instance on each call.
+ *
+ * @example
+ * ```ts
+ * const getThing = scoped(() => createThing())
+ * getThing() !== getThing()
+ * ```
+ *
+ * @example
+ * ```ts
+ * const getThing = scoped(() => createThing())
+ * const scope = createScope()
+ * getThing({ scope }) === getThing({ scope })
+ * ```
  *
  * @param resolver
- * The function that creates an instance using a resolution context.
+ * A function that returns a value of a particular type
+ * with a resolution context being passed to it.
  *
- * @returns The scoped provider instance.
+ * @returns The scoped provider.
  */
 declare const scoped: <T>(resolver: Resolver<T>) => Provider<T>;
 
@@ -193,31 +147,111 @@ type InferProviderCollectionResolutions<Providers extends ProviderList | Provide
  * if there'ss at least one `Promise` in the collection,
  * otherwise returns an untouched type.
  */
-type AwaitAllValuesInCollection<T extends any[] | Record<any, any>> = Promise<any> extends T[keyof T] ? Promise<{
+type AwaitValuesInCollection<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;
 /**
  * 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.
+ * and returns a list of resolutions. Returns a `Promise` of a list
+ * of awaited resolutions if there's at least one `Promise` in the resolutions.
+ *
+ * @example
+ * Only sync providers:
+ * ```ts
+ * const getA = scoped(() => createA())
+ * const getB = scoped(() => createB())
+ * const getC = scoped(() => createC())
+ *
+ * const scope = createScope()
+ * const resolutions = resolveList(
+ *     [getA, getB, getC],
+ *     { scope }
+ * )
+ *
+ * resolutions == [
+ *     getA({ scope }),
+ *     getB({ scope }),
+ *     getC({ scope })
+ * ]
+ * ```
+ *
+ * @example
+ * Some provider is async:
+ * ```ts
+ * const getA = scoped(() => createA())
+ * const getB = scoped(async () => await createB())
+ * const getC = scoped(() => createC())
+ *
+ * const scope = createScope()
+ * const resolutions = resolveList(
+ *     [getA, getB, getC],
+ *     { scope }
+ * )
+ *
+ * resolutions == [
+ *     getA({ scope }),
+ *     await getB({ scope }),
+ *     getC({ scope })
+ * ]
+ * ```
  *
  * @param providers - The list of providers.
  * @param context - The resolution context.
  *
  * @returns The list of resolutions.
  */
-declare const resolveList: <const Providers extends ProviderList>(providers: Providers, context?: ResolutionContext) => AwaitAllValuesInCollection<InferProviderCollectionResolutions<Providers>>;
+declare const resolveList: <const Providers extends ProviderList>(providers: Providers, context?: ResolutionContext) => AwaitValuesInCollection<InferProviderCollectionResolutions<Providers>>;
 /**
  * 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.
+ * Returns a `Promise` of a map of awaited resolutions if there's at least one
+ * `Promise` in the resolutions.
+ *
+ * @example
+ * Only sync providers:
+ * ```ts
+ * const getA = scoped(() => createA())
+ * const getB = scoped(() => createB())
+ * const getC = scoped(() => createC())
+ *
+ * const scope = createScope()
+ * const resolutions = resolveMap(
+ *     { a: getA, b: getB, c: getC },
+ *     { scope }
+ * )
+ *
+ * resolutions == {
+ *     a: getA({ scope }),
+ *     b: getB({ scope }),
+ *     c: getC({ scope })
+ * }
+ * ```
+ *
+ * @example
+ * Some provider is async:
+ * ```ts
+ * const getA = scoped(() => createA())
+ * const getB = scoped(async () => await createB())
+ * const getC = scoped(() => createC())
+ *
+ * const scope = createScope()
+ * const resolutions = await resolveMap(
+ *     { a: getA, b: getB, c: getC },
+ *     { scope }
+ * )
+ *
+ * resolutions == {
+ *     a: getA({ scope }),
+ *     b: await getB({ scope }),
+ *     c: getC({ scope })
+ * }
+ * ```
  *
  * @param providers - The map of providers.
  * @param context - The resolution context.
  *
  * @returns The map of resolutions.
  */
-declare const resolveMap: <const Providers extends ProviderRecord>(providers: Providers, context?: ResolutionContext) => AwaitAllValuesInCollection<InferProviderCollectionResolutions<Providers>>;
+declare const resolveMap: <const Providers extends ProviderRecord>(providers: Providers, context?: ResolutionContext) => AwaitValuesInCollection<InferProviderCollectionResolutions<Providers>>;
 
-export { type Lifetime, type MockMap, type Provider, type ResolutionContext, type Resolver, type Scope, createMockMap, createScope, provide, resolveList, resolveMap, scoped, singleton, transient };
+export { type MockMap, type Provider, type ResolutionContext, type Resolver, type Scope, createMockMap, createScope, resolveList, resolveMap, scoped, singleton, transient };

package/dist/index.js

@@ -21,7 +21,6 @@ var src_exports = {};
 __export(src_exports, {
   createMockMap: () => createMockMap,
   createScope: () => createScope,
-  provide: () => provide,
   resolveList: () => resolveList,
   resolveMap: () => resolveMap,
   scoped: () => scoped,
@@ -30,35 +29,42 @@ __export(src_exports, {
 });
 module.exports = __toCommonJS(src_exports);
 
-// src/helpers.ts
-var once = (fn) => {
-  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) => {
-  resolver = lifetime === "singleton" ? once(resolver) : resolver;
-  const resolve = (context) => {
+var transient = (resolver) => {
+  const instance = (context) => {
+    var _a;
+    const maybeMock = (_a = context == null ? void 0 : context.mocks) == null ? void 0 : _a.get(instance);
+    if (maybeMock) return maybeMock(context);
+    return resolver(context);
+  };
+  return instance;
+};
+var singleton = (resolver) => {
+  let resolved = false;
+  let resolution;
+  const instance = (context) => {
     var _a;
-    const maybeOwnMock = (_a = context == null ? void 0 : context.mocks) == null ? void 0 : _a.get(resolve);
-    if (maybeOwnMock) return maybeOwnMock(context);
-    if (lifetime !== "scoped" || !(context == null ? void 0 : context.scope)) return resolver(context);
-    const resolution = context.scope.has(resolve) ? context.scope.get(resolve) : resolver(context);
-    context.scope.set(resolve, resolution);
+    const maybeMock = (_a = context == null ? void 0 : context.mocks) == null ? void 0 : _a.get(instance);
+    if (maybeMock) return maybeMock(context);
+    if (resolved) return resolution;
+    resolution = resolver(context);
+    resolved = true;
     return resolution;
   };
-  return resolve;
+  return instance;
+};
+var scoped = (resolver) => {
+  const instance = (context) => {
+    var _a;
+    const maybeMock = (_a = context == null ? void 0 : context.mocks) == null ? void 0 : _a.get(instance);
+    if (maybeMock) return maybeMock(context);
+    if (!(context == null ? void 0 : context.scope)) return resolver(context);
+    const resolution = context.scope.has(resolver) ? context.scope.get(resolver) : resolver(context);
+    context.scope.set(resolver, resolution);
+    return resolution;
+  };
+  return instance;
 };
-var transient = (resolver) => provide("transient", resolver);
-var singleton = (resolver) => provide("singleton", resolver);
-var scoped = (resolver) => provide("scoped", resolver);
 
 // src/scope.ts
 var createScope = () => /* @__PURE__ */ new Map();
@@ -69,23 +75,27 @@ var createMockMap = () => /* @__PURE__ */ new Map();
 // 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;
+  const hasPromises = resolutions.some(
+    (resolution) => resolution instanceof Promise
+  );
+  return hasPromises ? Promise.all(resolutions) : resolutions;
 };
 var resolveMap = (providers, context) => {
-  let resolutionMapEntries = Object.entries(providers).map(
+  const resolutionMapEntries = Object.entries(providers).map(
     ([key, provider]) => [key, provider(context)]
   );
-  if (resolutionMapEntries.some(
+  const hasPromises = resolutionMapEntries.some(
     ([, resolution]) => resolution instanceof Promise
-  )) {
+  );
+  if (hasPromises) {
     return (async () => {
-      resolutionMapEntries = await Promise.all(
+      const awaitedEntries = await Promise.all(
         resolutionMapEntries.map(async ([key, resolution]) => [
           key,
           await resolution
         ])
       );
-      return Object.fromEntries(resolutionMapEntries);
+      return Object.fromEntries(awaitedEntries);
     })();
   }
   return Object.fromEntries(resolutionMapEntries);
@@ -94,7 +104,6 @@ var resolveMap = (providers, context) => {
 0 && (module.exports = {
   createMockMap,
   createScope,
-  provide,
   resolveList,
   resolveMap,
   scoped,

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/index.ts","../src/helpers.ts","../src/provider.ts","../src/scope.ts","../src/mock-map.ts","../src/collection-resolution.ts"],"sourcesContent":["export * from \"./provider\";\nexport * from \"./scope\";\nexport * from \"./mock-map\";\nexport * from \"./collection-resolution\";\n","/**\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(factory) 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(factory) 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    resolver = lifetime === \"singleton\" ? once(resolver) : resolver;\n\n    const resolve: Provider<T> = (context) => {\n        const maybeOwnMock = context?.mocks?.get(resolve);\n        if (maybeOwnMock) return maybeOwnMock(context);\n\n        if (lifetime !== \"scoped\" || !context?.scope) return resolver(context);\n\n        const resolution = context.scope.has(resolve)\n            ? context.scope.get(resolve)\n            : resolver(context);\n        context.scope.set(resolve, resolution);\n\n        return resolution;\n    };\n\n    return resolve;\n};\n\n/**\n * Creates a transient provider instance,\n * a wrapper around a resolver(factory) 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(factory) 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(factory) 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","import { Provider } from \"./provider\";\n\n/**\n * A map of providers to providers of the same type.\n * Lifetime is not a part of `Provider` type, so you can use\n * a different one if necessary.\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 otherProvider =\n *     transitive(() => ...)\n * const otherProviderMock: typeof otherProvider =\n *     scoped(() => ...)\n *\n * const mocks = createMockMap()\n * mocks.set(otherProvider, otherProviderMock)\n *\n * provider({ mocks })\n * ```\n */\nexport type MockMap = Omit<Map<Provider<any>, Provider<any>>, \"set\" | \"get\"> & {\n    /**\n     * Sets a mock for a provider.\n     *\n     * @param provider - The original provider.\n     * @param mock - The mock provider.\n     */\n    set<T>(provider: Provider<T>, mock: Provider<T>): MockMap;\n    /**\n     * Retrieves a mock of a provider. Returns undefined if there's none.\n     *\n     * @param provider - The provider.\n     */\n    get<T>(provider: Provider<T>): Provider<T> | undefined;\n};\n\n/**\n * Creates a mock map instance,\n * a map of providers to providers of the same type.\n * Lifetime is not a part of `Provider` type, so you can use\n * a different one if necessary.\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 otherProvider =\n *     transitive(() => ...)\n * const otherProviderMock: typeof otherProvider =\n *     scoped(() => ...)\n *\n * const mocks = createMockMap()\n * mocks.set(otherProvider, otherProviderMock)\n *\n * provider({ mocks })\n * ```\n *\n * @returns The mock map instance.\n */\nexport const createMockMap = (): MockMap => new Map();\n","import { Provider, ResolutionContext } from \"./provider\";\n\ntype ProviderList = Provider<any>[];\ntype ProviderRecord = Record<string, Provider<any>>;\n\ntype InferProviderCollectionResolutions<\n    Providers extends ProviderList | ProviderRecord,\n> = {\n    [K in keyof Providers]: Providers[K] extends Provider<infer T> ? T : never;\n};\n\n/**\n * Awaits all promises and wraps the collection in a promise\n * if there'ss at least one `Promise` in the collection,\n * otherwise returns an untouched type.\n */\ntype 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":";;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACMO,IAAM,OAAO,CAIhB,OACC;AACD,MAAI,WAAW;AACf,MAAI;AAEJ,SAAO,OAAO,OAAO,IAAI,SAAe;AACpC,QAAI,SAAU,QAAO;AAErB,aAAS,GAAG,GAAG,IAAI;AACnB,eAAW;AAEX,WAAO;AAAA,EACX,GAAG,EAAE;AACT;;;ACkDO,IAAM,UAAU,CACnB,UACA,aACc;AACd,aAAW,aAAa,cAAc,KAAK,QAAQ,IAAI;AAEvD,QAAM,UAAuB,CAAC,YAAY;AA/E9C;AAgFQ,UAAM,gBAAe,wCAAS,UAAT,mBAAgB,IAAI;AACzC,QAAI,aAAc,QAAO,aAAa,OAAO;AAE7C,QAAI,aAAa,YAAY,EAAC,mCAAS,OAAO,QAAO,SAAS,OAAO;AAErE,UAAM,aAAa,QAAQ,MAAM,IAAI,OAAO,IACtC,QAAQ,MAAM,IAAI,OAAO,IACzB,SAAS,OAAO;AACtB,YAAQ,MAAM,IAAI,SAAS,UAAU;AAErC,WAAO;AAAA,EACX;AAEA,SAAO;AACX;AAYO,IAAM,YAAY,CAAI,aACzB,QAAQ,aAAa,QAAQ;AAY1B,IAAM,YAAY,CAAI,aACzB,QAAQ,aAAa,QAAQ;AAc1B,IAAM,SAAS,CAAI,aAA0B,QAAQ,UAAU,QAAQ;;;AC5GvE,IAAM,cAAc,MAAa,oBAAI,IAAI;;;ACiCzC,IAAM,gBAAgB,MAAe,oBAAI,IAAI;;;AC1B7C,IAAM,cAAc,CACvB,WACA,YAGC;AACD,QAAM,cAAc,UAAU,IAAI,CAAC,aAAa,SAAS,OAAO,CAAC;AAEjE,SACI,YAAY,KAAK,CAAC,eAAe,sBAAsB,OAAO,IACxD,QAAQ,IAAI,WAAW,IACvB;AAEd;AAaO,IAAM,aAAa,CACtB,WACA,YAGC;AACD,MAAI,uBAAuB,OAAO,QAAQ,SAAS,EAAE;AAAA,IACjD,CAAC,CAAC,KAAK,QAAQ,MAAM,CAAC,KAAK,SAAS,OAAO,CAAC;AAAA,EAChD;AAEA,MACI,qBAAqB;AAAA,IACjB,CAAC,CAAC,EAAE,UAAU,MAAM,sBAAsB;AAAA,EAC9C,GACF;AACE,YAAQ,YAAY;AAChB,6BAAuB,MAAM,QAAQ;AAAA,QACjC,qBAAqB,IAAI,OAAO,CAAC,KAAK,UAAU,MAAM;AAAA,UAClD;AAAA,UACA,MAAM;AAAA,QACV,CAAC;AAAA,MACL;AAEA,aAAO,OAAO,YAAY,oBAAoB;AAAA,IAClD,GAAG;AAAA,EACP;AAEA,SAAO,OAAO,YAAY,oBAAoB;AAClD;","names":[]}
+{"version":3,"sources":["../src/index.ts","../src/provider.ts","../src/scope.ts","../src/mock-map.ts","../src/collection-resolution.ts"],"sourcesContent":["export * from \"./provider\";\nexport * from \"./scope\";\nexport * from \"./mock-map\";\nexport * from \"./collection-resolution\";\n","import { MockMap } from \"./mock-map\";\nimport { Scope } from \"./scope\";\n\n/**\n * A function that returns a value of a particular type\n * with a resolution context being passed to it.\n */\nexport type Resolver<T> = (context?: ResolutionContext) => T;\n\n/**\n * A function that resolves an instance or a `Promise` of a particular type\n * based on a resolution context passed to it.\n */\nexport type Provider<T> = Resolver<T>;\n\n/**\n * A context used by providers to resolve instances\n * based on current scope and mocks.\n */\nexport type ResolutionContext = {\n    scope?: Scope;\n    mocks?: MockMap;\n};\n\n/**\n * Creates a transient provider that will resolve a new instance on each call.\n *\n * @example\n * ```ts\n * const getThing = transient(() => createThing())\n * getThing() !== getThing()\n * ```\n *\n * @param resolver\n * A function that returns a value of a particular type\n * with a resolution context being passed to it.\n *\n * @returns The transient provider.\n */\nexport const transient = <T>(resolver: Resolver<T>): Provider<T> => {\n    const instance: Resolver<T> = (context) => {\n        const maybeMock = context?.mocks?.get(instance);\n        if (maybeMock) return maybeMock(context);\n\n        return resolver(context);\n    };\n\n    return instance;\n};\n\n/**\n * Creates a singleton provider that will resolve an instance once\n * and return it on every call.\n *\n * @example\n * ```ts\n * const getThing = singleton(() => createThing())\n * getThing() === getThing()\n * ```\n *\n * @param resolver\n * A function that returns a value of a particular type\n * with a resolution context being passed to it.\n *\n * @returns The singleton provider.\n */\nexport const singleton = <T>(resolver: Resolver<T>): Provider<T> => {\n    let resolved = false;\n    let resolution: T | undefined;\n\n    const instance: Resolver<T> = (context) => {\n        const maybeMock = context?.mocks?.get(instance);\n        if (maybeMock) return maybeMock(context);\n\n        if (resolved) return resolution!;\n\n        resolution = resolver(context);\n        resolved = true;\n\n        return resolution;\n    };\n\n    return instance;\n};\n\n/**\n * Creates a scoped provider that will take its resolution from a passed scope\n * or create a new one and save it if there is none.\n * If no scope is passed, it will create a new instance on each call.\n *\n * @example\n * ```ts\n * const getThing = scoped(() => createThing())\n * getThing() !== getThing()\n * ```\n *\n * @example\n * ```ts\n * const getThing = scoped(() => createThing())\n * const scope = createScope()\n * getThing({ scope }) === getThing({ scope })\n * ```\n *\n * @param resolver\n * A function that returns a value of a particular type\n * with a resolution context being passed to it.\n *\n * @returns The scoped provider.\n */\nexport const scoped = <T>(resolver: Resolver<T>): Provider<T> => {\n    const instance: Resolver<T> = (context) => {\n        const maybeMock = context?.mocks?.get(instance);\n        if (maybeMock) return maybeMock(context);\n\n        if (!context?.scope) return resolver(context);\n\n        const resolution = context.scope.has(resolver)\n            ? context.scope.get(resolver)\n            : resolver(context);\n        context.scope.set(resolver, resolution);\n\n        return resolution;\n    };\n\n    return instance;\n};\n","import { Resolver } from \"./provider\";\n\n/**\n * A `Map` of providers to their instances\n * that is then passed to a provider call in a resolution context object\n * to resolve instances of scoped providers within it.\n */\nexport type Scope = Map<Resolver<any>, any>;\n\n/**\n * Creates a `Map` of providers to their instances\n * that is then passed to a provider call in a resolution context object\n * to resolve instances of scoped providers within it.\n *\n * @example\n * ```ts\n * const requestScope = createScope()\n *\n * app.use(() => {\n *     const db = getDb({ scope: requestScope })\n *     // ...\n * })\n * ```\n *\n * @returns The map instance.\n */\nexport const createScope = (): Scope => new Map();\n","import { Resolver } from \"./provider\";\n\n/**\n * A `Map` of providers to providers of the same type\n * which is then passed to a provider call in a resolution context object\n * in order to replace providers with their mocks.\n */\nexport type MockMap = Omit<Map<Resolver<any>, Resolver<any>>, \"set\" | \"get\"> & {\n    /**\n     * Sets a mock for a provider.\n     *\n     * @param provider - The original provider.\n     * @param mock - The mock provider.\n     */\n    set<T>(provider: Resolver<T>, mock: Resolver<T>): MockMap;\n    /**\n     * Retrieves a mock of a provider. Returns undefined if there's none.\n     *\n     * @param provider - The provider.\n     */\n    get<T>(provider: Resolver<T>): Resolver<T> | undefined;\n};\n\n/**\n * Creates a `Map` of providers to providers of the same type\n * which is then passed to a provider call in a resolution context object\n * in order to replace providers with their mocks.\n *\n * @example\n * ```ts\n * const mocks = createMockMap()\n *     .set(getConfig, getTestConfig)\n *\n * getThing({ mocks })\n * ```\n *\n * @returns The map instance.\n */\nexport const createMockMap = (): MockMap => new Map();\n","import { Provider, ResolutionContext } from \"./provider\";\n\ntype ProviderList = Provider<any>[];\ntype ProviderRecord = Record<string, Provider<any>>;\n\ntype InferProviderCollectionResolutions<\n    Providers extends ProviderList | ProviderRecord,\n> = {\n    [K in keyof Providers]: Providers[K] extends Provider<infer T> ? T : never;\n};\n\n/**\n * Awaits all promises and wraps the collection in a promise\n * if there'ss at least one `Promise` in the collection,\n * otherwise returns an untouched type.\n */\ntype AwaitValuesInCollection<T extends any[] | Record<any, any>> =\n    Promise<any> extends T[keyof T]\n        ? Promise<{\n              [I in keyof T]: T[I] extends Promise<infer T> ? T : T[I];\n          }>\n        : T;\n\n/**\n * Calls every provider in a list with a provided resolution context\n * and returns a list of resolutions. Returns a `Promise` of a list\n * of awaited resolutions if there's at least one `Promise` in the resolutions.\n *\n * @example\n * Only sync providers:\n * ```ts\n * const getA = scoped(() => createA())\n * const getB = scoped(() => createB())\n * const getC = scoped(() => createC())\n *\n * const scope = createScope()\n * const resolutions = resolveList(\n *     [getA, getB, getC],\n *     { scope }\n * )\n *\n * resolutions == [\n *     getA({ scope }),\n *     getB({ scope }),\n *     getC({ scope })\n * ]\n * ```\n *\n * @example\n * Some provider is async:\n * ```ts\n * const getA = scoped(() => createA())\n * const getB = scoped(async () => await createB())\n * const getC = scoped(() => createC())\n *\n * const scope = createScope()\n * const resolutions = resolveList(\n *     [getA, getB, getC],\n *     { scope }\n * )\n *\n * resolutions == [\n *     getA({ scope }),\n *     await getB({ scope }),\n *     getC({ scope })\n * ]\n * ```\n *\n * @param providers - The list of providers.\n * @param context - The resolution context.\n *\n * @returns The list of resolutions.\n */\nexport const resolveList = <const Providers extends ProviderList>(\n    providers: Providers,\n    context?: ResolutionContext,\n): AwaitValuesInCollection<\n    InferProviderCollectionResolutions<Providers>\n> => {\n    const resolutions = providers.map((provider) => provider(context));\n\n    const hasPromises = resolutions.some(\n        (resolution) => resolution instanceof Promise,\n    );\n\n    return (hasPromises ? Promise.all(resolutions) : resolutions) as any;\n};\n\n/**\n * Calls every provider in a map with a provided resolution context\n * and returns a map with identical keys but with resolutions in values instead.\n * Returns a `Promise` of a map of awaited resolutions if there's at least one\n * `Promise` in the resolutions.\n *\n * @example\n * Only sync providers:\n * ```ts\n * const getA = scoped(() => createA())\n * const getB = scoped(() => createB())\n * const getC = scoped(() => createC())\n *\n * const scope = createScope()\n * const resolutions = resolveMap(\n *     { a: getA, b: getB, c: getC },\n *     { scope }\n * )\n *\n * resolutions == {\n *     a: getA({ scope }),\n *     b: getB({ scope }),\n *     c: getC({ scope })\n * }\n * ```\n *\n * @example\n * Some provider is async:\n * ```ts\n * const getA = scoped(() => createA())\n * const getB = scoped(async () => await createB())\n * const getC = scoped(() => createC())\n *\n * const scope = createScope()\n * const resolutions = await resolveMap(\n *     { a: getA, b: getB, c: getC },\n *     { scope }\n * )\n *\n * resolutions == {\n *     a: getA({ scope }),\n *     b: await getB({ scope }),\n *     c: getC({ scope })\n * }\n * ```\n *\n * @param providers - The map of providers.\n * @param context - The resolution context.\n *\n * @returns The map of resolutions.\n */\nexport const resolveMap = <const Providers extends ProviderRecord>(\n    providers: Providers,\n    context?: ResolutionContext,\n): AwaitValuesInCollection<\n    InferProviderCollectionResolutions<Providers>\n> => {\n    const resolutionMapEntries = Object.entries(providers).map(\n        ([key, provider]) => [key, provider(context)],\n    );\n\n    const hasPromises = resolutionMapEntries.some(\n        ([, resolution]) => resolution instanceof Promise,\n    );\n\n    if (hasPromises) {\n        return (async () => {\n            const awaitedEntries = await Promise.all(\n                resolutionMapEntries.map(async ([key, resolution]) => [\n                    key,\n                    await resolution,\n                ]),\n            );\n            return Object.fromEntries(awaitedEntries);\n        })() as any;\n    }\n\n    return Object.fromEntries(resolutionMapEntries);\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACuCO,IAAM,YAAY,CAAI,aAAuC;AAChE,QAAM,WAAwB,CAAC,YAAY;AAxC/C;AAyCQ,UAAM,aAAY,wCAAS,UAAT,mBAAgB,IAAI;AACtC,QAAI,UAAW,QAAO,UAAU,OAAO;AAEvC,WAAO,SAAS,OAAO;AAAA,EAC3B;AAEA,SAAO;AACX;AAkBO,IAAM,YAAY,CAAI,aAAuC;AAChE,MAAI,WAAW;AACf,MAAI;AAEJ,QAAM,WAAwB,CAAC,YAAY;AAtE/C;AAuEQ,UAAM,aAAY,wCAAS,UAAT,mBAAgB,IAAI;AACtC,QAAI,UAAW,QAAO,UAAU,OAAO;AAEvC,QAAI,SAAU,QAAO;AAErB,iBAAa,SAAS,OAAO;AAC7B,eAAW;AAEX,WAAO;AAAA,EACX;AAEA,SAAO;AACX;AA0BO,IAAM,SAAS,CAAI,aAAuC;AAC7D,QAAM,WAAwB,CAAC,YAAY;AA9G/C;AA+GQ,UAAM,aAAY,wCAAS,UAAT,mBAAgB,IAAI;AACtC,QAAI,UAAW,QAAO,UAAU,OAAO;AAEvC,QAAI,EAAC,mCAAS,OAAO,QAAO,SAAS,OAAO;AAE5C,UAAM,aAAa,QAAQ,MAAM,IAAI,QAAQ,IACvC,QAAQ,MAAM,IAAI,QAAQ,IAC1B,SAAS,OAAO;AACtB,YAAQ,MAAM,IAAI,UAAU,UAAU;AAEtC,WAAO;AAAA,EACX;AAEA,SAAO;AACX;;;ACnGO,IAAM,cAAc,MAAa,oBAAI,IAAI;;;ACYzC,IAAM,gBAAgB,MAAe,oBAAI,IAAI;;;ACmC7C,IAAM,cAAc,CACvB,WACA,YAGC;AACD,QAAM,cAAc,UAAU,IAAI,CAAC,aAAa,SAAS,OAAO,CAAC;AAEjE,QAAM,cAAc,YAAY;AAAA,IAC5B,CAAC,eAAe,sBAAsB;AAAA,EAC1C;AAEA,SAAQ,cAAc,QAAQ,IAAI,WAAW,IAAI;AACrD;AAqDO,IAAM,aAAa,CACtB,WACA,YAGC;AACD,QAAM,uBAAuB,OAAO,QAAQ,SAAS,EAAE;AAAA,IACnD,CAAC,CAAC,KAAK,QAAQ,MAAM,CAAC,KAAK,SAAS,OAAO,CAAC;AAAA,EAChD;AAEA,QAAM,cAAc,qBAAqB;AAAA,IACrC,CAAC,CAAC,EAAE,UAAU,MAAM,sBAAsB;AAAA,EAC9C;AAEA,MAAI,aAAa;AACb,YAAQ,YAAY;AAChB,YAAM,iBAAiB,MAAM,QAAQ;AAAA,QACjC,qBAAqB,IAAI,OAAO,CAAC,KAAK,UAAU,MAAM;AAAA,UAClD;AAAA,UACA,MAAM;AAAA,QACV,CAAC;AAAA,MACL;AACA,aAAO,OAAO,YAAY,cAAc;AAAA,IAC5C,GAAG;AAAA,EACP;AAEA,SAAO,OAAO,YAAY,oBAAoB;AAClD;","names":[]}

package/dist/index.mjs

@@ -1,32 +1,39 @@
-// src/helpers.ts
-var once = (fn) => {
-  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) => {
-  resolver = lifetime === "singleton" ? once(resolver) : resolver;
-  const resolve = (context) => {
+var transient = (resolver) => {
+  const instance = (context) => {
+    var _a;
+    const maybeMock = (_a = context == null ? void 0 : context.mocks) == null ? void 0 : _a.get(instance);
+    if (maybeMock) return maybeMock(context);
+    return resolver(context);
+  };
+  return instance;
+};
+var singleton = (resolver) => {
+  let resolved = false;
+  let resolution;
+  const instance = (context) => {
     var _a;
-    const maybeOwnMock = (_a = context == null ? void 0 : context.mocks) == null ? void 0 : _a.get(resolve);
-    if (maybeOwnMock) return maybeOwnMock(context);
-    if (lifetime !== "scoped" || !(context == null ? void 0 : context.scope)) return resolver(context);
-    const resolution = context.scope.has(resolve) ? context.scope.get(resolve) : resolver(context);
-    context.scope.set(resolve, resolution);
+    const maybeMock = (_a = context == null ? void 0 : context.mocks) == null ? void 0 : _a.get(instance);
+    if (maybeMock) return maybeMock(context);
+    if (resolved) return resolution;
+    resolution = resolver(context);
+    resolved = true;
     return resolution;
   };
-  return resolve;
+  return instance;
+};
+var scoped = (resolver) => {
+  const instance = (context) => {
+    var _a;
+    const maybeMock = (_a = context == null ? void 0 : context.mocks) == null ? void 0 : _a.get(instance);
+    if (maybeMock) return maybeMock(context);
+    if (!(context == null ? void 0 : context.scope)) return resolver(context);
+    const resolution = context.scope.has(resolver) ? context.scope.get(resolver) : resolver(context);
+    context.scope.set(resolver, resolution);
+    return resolution;
+  };
+  return instance;
 };
-var transient = (resolver) => provide("transient", resolver);
-var singleton = (resolver) => provide("singleton", resolver);
-var scoped = (resolver) => provide("scoped", resolver);
 
 // src/scope.ts
 var createScope = () => /* @__PURE__ */ new Map();
@@ -37,23 +44,27 @@ var createMockMap = () => /* @__PURE__ */ new Map();
 // 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;
+  const hasPromises = resolutions.some(
+    (resolution) => resolution instanceof Promise
+  );
+  return hasPromises ? Promise.all(resolutions) : resolutions;
 };
 var resolveMap = (providers, context) => {
-  let resolutionMapEntries = Object.entries(providers).map(
+  const resolutionMapEntries = Object.entries(providers).map(
     ([key, provider]) => [key, provider(context)]
   );
-  if (resolutionMapEntries.some(
+  const hasPromises = resolutionMapEntries.some(
     ([, resolution]) => resolution instanceof Promise
-  )) {
+  );
+  if (hasPromises) {
     return (async () => {
-      resolutionMapEntries = await Promise.all(
+      const awaitedEntries = await Promise.all(
         resolutionMapEntries.map(async ([key, resolution]) => [
           key,
           await resolution
         ])
       );
-      return Object.fromEntries(resolutionMapEntries);
+      return Object.fromEntries(awaitedEntries);
     })();
   }
   return Object.fromEntries(resolutionMapEntries);
@@ -61,7 +72,6 @@ var resolveMap = (providers, context) => {
 export {
   createMockMap,
   createScope,
-  provide,
   resolveList,
   resolveMap,
   scoped,