# HG changeset patch
# User cin
# Date 2023-02-21 22:49:42
# Node ID 58282d42a47b06e0e30faa0d72e9aea86e696bca
# Parent  5683fe88e2a507228e588a0528dfd2c99df609fc

improved typings

diff --git a/src/main/ts/interfaces.ts b/src/main/ts/interfaces.ts
--- a/src/main/ts/interfaces.ts
+++ b/src/main/ts/interfaces.ts
@@ -27,12 +27,26 @@ export interface Resolver<S extends obje
     <K extends keyof S, O extends { lazy?: false; default?: unknown }>(name: K, opts?: O): (O extends { default: infer T } ? T : never) | NonNullable<S[K]>;
 }
 
-export type DepsMap<K extends key, SK extends key> = { [k in K]: SK | Ref<SK, boolean, unknown> };
+export type DepsMap<S extends object> = {
+    [k in key]: Refs<S>
+};
+
+export type Refs<S extends object> = {
+    [k in keyof S]: Ref<k, boolean, S[k]>;
+}[keyof S] | keyof S;
+
+export type Ref<K extends key, L extends boolean, D> = { name: K, lazy?: L, default?: D | null };
 
-export type Ref<K extends key, L extends boolean, D> = { name: K, lazy?: L } | { name: K, lazy?: L, default: D };
+export type Lazy<T, L extends boolean> = L extends true ? () => T : T;
+
+export type InferDefault<T> = T extends { default: infer D } ? D : never;
 
-export type Resolved<S, K extends keyof S, L, D> =
-    L extends true ? () => NonNullable<S[K]> | (unknown extends D ? never : D) : NonNullable<S[K]> | (unknown extends D ? never : D);
+export type Resolve<S extends object, R> =
+    R extends keyof S ? NonNullable<S[R]> :
+    R extends Ref<infer K, infer L, unknown> ? 
+        K extends keyof S ? Lazy<NonNullable<S[K]> | InferDefault<R>, L> :
+        never:
+    never;
 
 export interface IDescriptorBuilder<S extends object, T, R extends object, O extends keyof S> {
 
@@ -42,12 +56,9 @@ export interface IDescriptorBuilder<S ex
      */
     factory(f: (refs: R) => T): void;
 
-    wants<X extends DepsMap<Exclude<key, keyof R>, keyof S>>(refs: X):
+    wants<X extends DepsMap<S> & Record<keyof R & keyof X, never>>(refs: X):
         IDescriptorBuilder<S, T, R & {
-            [k in keyof X]:
-            X[k] extends keyof S ? NonNullable<S[X[k]]> :
-            X[k] extends Ref<infer K, infer L, infer D> ? Resolved<S, K & keyof S, L, D> :
-            never
+            [k in keyof X]: Resolve<S, X[k]>;
         }, O>
 
     override<K extends O>(name: K, builder: RegistrationBuilder<S, NonNullable<S[K]>>): this;
diff --git a/src/test/ts/t/container.ts b/src/test/ts/t/container.ts
--- a/src/test/ts/t/container.ts
+++ b/src/test/ts/t/container.ts
@@ -1,7 +1,7 @@
 /* eslint max-classes-per-file: ["error", 20] */
 import { describe, it } from "mocha";
 import { Container } from "../Container";
-import { ContainerServices } from "../interfaces";
+import { ContainerServices, DepsMap, Refs, Resolver } from "../interfaces";
 import { fluent } from "../traits";
 
 class Foo {
@@ -31,6 +31,19 @@ interface ServicesB {
     zoo?: Foo;
 }
 
+declare const resolver: Resolver<Services>;
+
+const foo = resolver("foo", {lazy: true});
+
+const mmap = <X extends DepsMap<Services, string>>(m: X) => {};
+
+const refs: Refs<Services> = {name: "bar", default: undefined};
+
+mmap({
+   fooz: {name: "foo", lazy: false, default: undefined },
+   ooz: "bar"
+});
+
 interface SharedServices {
     foo: Foo;
 
@@ -47,13 +60,17 @@ const config = fluent()
             .lifetime("context") // тип активации, время жизни
             .wants({
                 zoo: "zoo", // зависимость
+                bar: "bar",
 
-                zoo$: { name: "zoo", lazy: true } // отложенная активация, 
+                $zoo: { name: "foo", lazy: true, } // отложенная активация, 
                 //фабричный метод
             })
-            .factory(({ zoo$ }) => // фабрика получает объект с именованными зависимостями
+            .wants({
+                zoom: "bar"
+            })
+            .factory(({ $zoo, zoo }) => // фабрика получает объект с именованными зависимостями
                 // удобно для деструктурирования
-                new Bar(zoo$) // создается экземпляр сервиса
+                new Bar($zoo) // создается экземпляр сервиса
             ),
         foo: it => it.factory(() => new Foo()),
         baz: it => it.value(new Foo())