implab/implabjs-di Commit - r8:80cb5668e4a7

working on typings

cin -

r8:80cb5668e4a7 default

parent child

Context file:

r8:80cb5668e4a7

Collapse all files

src/main/ts/FluentConfiguration.ts +2 -2

             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>> = {};
                  * @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>>;
                 }

src/main/ts/interfaces.ts +51 -22

             /**
              * @template S Карта доступных зависимостей
              */
-            export interface Resolver<S extends object> {
+            export interface Resolver<S> {
                 /**
                  * Функция для разрешения зависимостей, поддерживает создание фабричных методов,
                  * отложенную активацию и значение по-умолчанию для сервисов
                 <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> = {
+            export type DepsMap<S> = {
-                [k in key]: Refs<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 };
             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 :
                 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]>;
                 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;
             }
                 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>;

src/main/ts/traits.ts +1 -1

             import { FluentConfiguration } from "./FluentConfiguration";
             import { IDestroyable } from "./interfaces";
-            export function fluent<S extends object = object>() {
+            export function fluent<S = {}>() {
                 return new FluentConfiguration<S>();
             }

src/test/ts/t/container.ts +18 -5

             /* 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 {
                 bar?: Bar;
                 baz: Foo;
+                container: string;
             }
             interface ServicesB {
             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 },
                 .declare<Services>()
                 .declare<ServicesB>()
                 .register({
+                    zoo: it => {},
                     bar: it => it
                         .lifetime("context") // тип активации, время жизни
                         .wants({
                 })
                 .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

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages