# HG changeset patch
# User cin
# Date 2023-02-22 17:23:50
# Node ID 80cb5668e4a72987ee3893e4f300c37442296498
# Parent  58282d42a47b06e0e30faa0d72e9aea86e696bca

working on typings

diff --git a/src/main/ts/FluentConfiguration.ts b/src/main/ts/FluentConfiguration.ts
--- a/src/main/ts/FluentConfiguration.ts
+++ b/src/main/ts/FluentConfiguration.ts
@@ -3,7 +3,7 @@ import { ConfigurableKeys, ContainerServ
 import { ServiceContainer } from "./interfaces";
 import { argumentNotNull, each, isKey } from "./traits";
 
-export class FluentConfiguration<S extends object, Y extends ConfigurableKeys<S> = ConfigurableKeys<S>> {
+export class FluentConfiguration<S, Y extends ConfigurableKeys<S> = ConfigurableKeys<S>> {
 
     private _builders: Partial<RegistrationBuildersMap<S>> = {};
 
@@ -12,7 +12,7 @@ export class FluentConfiguration<S exten
      * @template D The map of the services
      * @returns self
      */
-    declare<D extends Partial<Pick<S, keyof D & keyof S>>>(): FluentConfiguration<S & D, Y | ConfigurableKeys<D>> {
+    declare<D extends Pick<S, keyof D & keyof S>>(): FluentConfiguration<S & D, Y | ConfigurableKeys<D>> {
         return this as FluentConfiguration<S & D, Y | ConfigurableKeys<D>>;
     }
 
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
@@ -7,7 +7,7 @@ export interface IDestroyable {
 /**
  * @template S Карта доступных зависимостей
  */
-export interface Resolver<S extends object> {
+export interface Resolver<S> {
     /**
      * Функция для разрешения зависимостей, поддерживает создание фабричных методов,
      * отложенную активацию и значение по-умолчанию для сервисов 
@@ -27,13 +27,13 @@ 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<S extends object> = {
-    [k in key]: Refs<S>
+export type DepsMap<S> = {
+    [k in key]: Refs<S> | keyof S;
 };
 
-export type Refs<S extends object> = {
+export type Refs<S> = {
     [k in keyof S]: Ref<k, boolean, S[k]>;
-}[keyof S] | keyof S;
+}[keyof S];
 
 export type Ref<K extends key, L extends boolean, D> = { name: K, lazy?: L, default?: D | null };
 
@@ -41,21 +41,40 @@ export type Lazy<T, L extends boolean> =
 
 export type InferDefault<T> = T extends { default: infer D } ? D : never;
 
-export type Resolve<S extends object, R> =
+export type Resolve<S, 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:
+    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> {
+/**
+ * Интерфейс для конфигурирования сервиса в контейнере
+ */
+export interface IDescriptorBuilder<S, T, R, O extends keyof S> {
 
-    /**
+    /** Указывает фабрика для создания экземпляра сервиса, фабрика передается
+     * в виде параметра. При вызове фабрике будет передан объект с зависимостями,
+     * которые были предварительно указаны вызовами метода `wants(...)`
      * 
-     * @param f
+     * Вызов данного метода завершает конфигурирование сервиса.
+     * 
+     * @param f Фабрика для создания экземпляра сервиса
      */
     factory(f: (refs: R) => T): void;
 
+    /**
+     * Используется для указания зависимостей, которые потребуются фабричному
+     * методу при создании нового экземпляра сервиса. Данный метод может быть
+     * вызван несколько раз подряд, при этом вызовы этого метода имеют
+     * кумулятивный эффект.
+     * 
+     * @template X Тип объекта с зависимостями, которые требуется получить при
+     *   создании экземпляра фабрики при помощи фабричного метода.
+     * @param refs Объект с описанием зависимостей
+     * @returns Возвращает дескриптор сервиса, в котором указаны необходимые
+     *   зависимости
+     */
     wants<X extends DepsMap<S> & Record<keyof R & keyof X, never>>(refs: X):
         IDescriptorBuilder<S, T, R & {
             [k in keyof X]: Resolve<S, X[k]>;
@@ -67,50 +86,60 @@ export interface IDescriptorBuilder<S ex
     lifetime(lifetime: "singleton", typeId: string | number | object): this;
     lifetime(lifetime: ILifetime<T> | Exclude<ActivationType, "singleton">): this;
 
+    /** Указывает функцию для освобождения экземпляра сервиса для случаев, когда
+     * время жизни привязано к контейнеру.
+     */
     cleanup(cb: (item: T) => void): this;
 
+    /**
+     * Регистрирует в контейнере постоянное значение в качестве реализации сервиса.
+     * 
+     * @param v Экземпляр реализации сервиса.
+     */
     value(v: T): void;
 }
 
-export type RegistrationBuilder<S extends object, T> = (d: IDescriptorBuilder<S, T, object, ConfigurableKeys<S>>) => void;
+export type RegistrationBuilder<S, T> = (d: IDescriptorBuilder<S, T, object, ConfigurableKeys<S>>) => void;
 
 export type RegistrationBuildersMap<S extends Configurable<S>, K extends keyof S = keyof S> = {
     [k in K]-?: RegistrationBuilder<ContainerServices<S>, NonNullable<S[k]>>
 };
 
-export interface Descriptor<S extends object, T> {
+export interface Descriptor<S, T> {
     activate(context: IActivationContext<S>): T;
 }
 
-export interface IActivationContext<S extends object> extends ServiceLocator<S> {
+export interface IActivationContext<S> extends ServiceLocator<S> {
     createLifetime<T>(): ILifetime<T>;
 
     createContainerLifetime<T>(): ILifetime<T>;
 }
 
-export type RegistrationMap<S extends object, K extends keyof S = keyof S> = {
+export type RegistrationMap<S, K extends keyof S = keyof S> = {
     [k in K]-?: Descriptor<S, S[k]>;
 };
 
-export interface ContainerProvided<S extends Configurable<S>> {
+export interface ContainerProvided<S> {
     container: ServiceLocator<ContainerServices<S>>;
 
     childContainer: IContainerBuilder<S>;
 }
 
-export type Configurable<S> = { [k in keyof S & (keyof ContainerProvided<never>)]: never; };
+export type Configurable<S> = { [k in keyof S]: k extends ProvidedKeys ? never : S[k]; };
 
 export type ProvidedKeys = keyof ContainerProvided<never>;
 
-export type ContainerServices<S extends Configurable<S>> = S & ContainerProvided<S>;
+export type ContainerServices<S> =
+    { [k in keyof S as k extends ProvidedKeys ? never: k]: S[k] } &
+    ContainerProvided<S>;
 
-export type ConfigurableKeys<S extends object> = Exclude<keyof S, ProvidedKeys>;
+export type ConfigurableKeys<S> = Exclude<keyof S, ProvidedKeys>;
 
-export type ConfigurableServices<S extends object> = Pick<S, ConfigurableKeys<S>>;
+export type ConfigurableServices<S> = Pick<S, ConfigurableKeys<S>>;
 
-export type ContainerKeys<S extends Configurable<S>> = keyof S | keyof ContainerProvided<never>;
+export type ContainerKeys<S> = keyof S | ProvidedKeys;
 
-export interface ServiceLocator<S extends object> {
+export interface ServiceLocator<S> {
     resolve<K extends keyof S>(name: K): NonNullable<S[K]>;
     resolve<K extends keyof S, T>(name: K, def: T): NonNullable<S[K]> | T;
 }
@@ -119,14 +148,14 @@ export interface LifetimeContainer {
     createLifetime<T>(): ILifetime<T>;
 }
 
-export interface ServiceContainer<S extends Configurable<S>> extends
+export interface ServiceContainer<S> extends
     ServiceLocator<ContainerServices<S>>,
     IDestroyable {
 
     createChildContainer(): IContainerBuilder<S>;
 }
 
-export interface IContainerBuilder<S extends Configurable<S>> {
+export interface IContainerBuilder<S> {
     createServiceBuilder<K extends keyof S>(name: K): IDescriptorBuilder<S, NonNullable<S[K]>, object, keyof S>;
 
     build(): ServiceContainer<S>;
diff --git a/src/main/ts/traits.ts b/src/main/ts/traits.ts
--- a/src/main/ts/traits.ts
+++ b/src/main/ts/traits.ts
@@ -1,7 +1,7 @@
 import { FluentConfiguration } from "./FluentConfiguration";
 import { IDestroyable } from "./interfaces";
 
-export function fluent<S extends object = object>() {
+export function fluent<S = {}>() {
     return new FluentConfiguration<S>();
 }
 
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,8 @@
 /* eslint max-classes-per-file: ["error", 20] */
 import { describe, it } from "mocha";
 import { Container } from "../Container";
-import { ContainerServices, DepsMap, Refs, Resolver } from "../interfaces";
+import { ContainerBuilder } from "../ContainerBuilder";
+import { ConfigurableKeys, ContainerProvided, ContainerServices, DepsMap, Refs, Resolver } from "../interfaces";
 import { fluent } from "../traits";
 
 class Foo {
@@ -20,6 +21,8 @@ interface Services {
     bar?: Bar;
 
     baz: Foo;
+
+    container: string;
 }
 
 interface ServicesB {
@@ -35,9 +38,18 @@ declare const resolver: Resolver<Service
 
 const foo = resolver("foo", {lazy: true});
 
-const mmap = <X extends DepsMap<Services, string>>(m: X) => {};
+const mmap = <X extends DepsMap<Services>>(m: X) => {};
+
+declare const refs: Refs<Services>;
 
-const refs: Refs<Services> = {name: "bar", default: undefined};
+if (refs && refs.name === "foo") {
+    refs.default;
+}
+
+declare const x: ContainerServices<Services>;
+
+x.container.resolve("container");
+
 
 mmap({
    fooz: {name: "foo", lazy: false, default: undefined },
@@ -56,6 +68,7 @@ const config = fluent()
     .declare<Services>()
     .declare<ServicesB>()
     .register({
+        zoo: it => {},
         bar: it => it
             .lifetime("context") // тип активации, время жизни
             .wants({
@@ -77,11 +90,11 @@ const config = fluent()
     })
     .done({});
 
-declare const container: Container<object>;
+declare const container: ContainerBuilder<{}>;
 const c2 = config.configure(container);
 
 c2.resolve("foo");
 
 declare const m :ContainerServices<{foo: Foo}>["container"];
 
-m.resolve("container").resolve("container");
\ No newline at end of file
+m.resolve("container").resolve("container").resolve("foo");
\ No newline at end of file