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 { DescriptorBuilder } from "./DescriptorBuilder";
             import { ConfigurableKeys, ContainerServices, RegistrationBuildersMap, ExtractRequired, IContainerBuilder } from "./interfaces";
             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>> = {};
                 /** Adds a declaration of the services to the current config.
                  *
                  * @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>>;
                 }
                 /** Adds compile-time information about the already provided services
                  *
                  * @template P The map of the provided services
                  * @returns self
                  */
                 provided<P extends Pick<S, keyof P & keyof S>>(): FluentConfiguration<S & P, Exclude<Y, keyof P>> {
                     return this as FluentConfiguration<S & P, Exclude<Y, keyof P>>;
                 }
                 /** Register the service.
                  *
                  * @param name The name of the service
                  * @param builder The service builder
                  * @returns self
                  */
                 register<K extends Y>(name: K, builder: RegistrationBuildersMap<S>[K]): FluentConfiguration<S, Exclude<Y, K>>;
                 /** Registers the collection of services
                  * @param config The collection of services to register.
                  * @returns self
                  */
                 register<K extends Y>(config: RegistrationBuildersMap<S, K>): FluentConfiguration<S, Exclude<Y, K>>;
                 register<K extends Y>(nameOrConfig: K | RegistrationBuildersMap<S, K>, builder?: RegistrationBuildersMap<S>[K]) {
                     if (isKey(nameOrConfig)) {
                         argumentNotNull(builder, "builder");
                         this._builders[nameOrConfig] = builder;
                     } else {
                         each(nameOrConfig, (v, k) => this.register(k, v));
                     }
                     return this as FluentConfiguration<S, Exclude<Y, K>>;
                 }
                 /**
                  * This method is used to enable a compile time check of the configuration.
                  * If there are not configured services in the configuration the compiler
                  * will trigger the error.
                  *
                  * @param missing Empty object literal should always be specified.
                  * @returns self
                  */
                 // eslint-disable-next-line @typescript-eslint/no-unused-vars
                 done<M extends ExtractRequired<S,Y>>(missing: M) {
                     return this;
                 }
                 configure<T extends IContainerBuilder<S>>(builder: T) {
                     each(this._builders, (v, k) => {
                         v(builder.createServiceBuilder(k));
                     });
                     builder.build() as T & ServiceContainer<S>;
                 }
             }

src/main/ts/interfaces.ts +54 -25

             import { key } from "./traits";
             export interface IDestroyable {
                 destroy(): void;
             }
             /**
              * @template S Карта доступных зависимостей
              */
-            export interface Resolver<S extends object> {
+            export interface Resolver<S> {
                 /**
                  * Функция для разрешения зависимостей, поддерживает создание фабричных методов,
                  * отложенную активацию и значение по-умолчанию для сервисов
                  * @template K Ключ сервиса из {@link S}
                  * @template O Тип параметра {@link opts} используется для выведения типа
                  *   возвращаемого значения.
                  * @param name Ключ сервиса, который будет разрешен.
                  * @param {boolean=} opts.lazy Признак того, что требуется отложенная активация,
                  *   будет возвращен фабричный метод для получения зависимости. Если не указан,
                  *   то считается `false`.
                  * @param {any=} opts.default Значение по умолчанию, если в контейнере указанный
                  *   сервис не зарегистрирован
                  * @returns Либо фабричный метод для получения зависимости, либо значение зависимости
                  * @throws Error Если зависимость не найдена и не предоставлено значение по-умолчанию
                  */
                 <K extends keyof S, O extends { lazy: true; default?: unknown }>(name: K, opts?: O): () => (O extends { default: infer T } ? T : never) | NonNullable<S[K]>;
                 <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 Lazy<T, L extends boolean> = L extends true ? () => T : T;
             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> :
+                K extends keyof S ? Lazy<NonNullable<S[K]> | InferDefault<R>, L> :
-                    never:
+                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]>;
                     }, O>
                 override<K extends O>(name: K, builder: RegistrationBuilder<S, NonNullable<S[K]>>): this;
                 override<K extends O>(services: { [name in K]: RegistrationBuilder<S, NonNullable<S[K]>> }): this;
                 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;
             }
             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>;
             }
             export type ActivationType = "singleton" | "container" | "hierarchy" | "context" | "call";
             /**
              * Интерфейс для управления жизнью экземпляра объекта. Каждая регистрация имеет
              * свой собственный объект `ILifetime`, который создается при первой активации
              */
             export interface ILifetime<T> {
                 /** Проверяет, что уже создан экземпляр объекта */
                 has(): boolean;
                 get(): T;
                 initialize(context: IActivationContext<object>): void;
                 store(item: T, cleanup?: (item: T) => void): void;
             }
             export type ExtractRequired<T, K extends keyof T = keyof T> = { [p in K as (undefined extends T[p] ? never : p)]-?: T[p] };

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>();
             }
             export type key = string | number | symbol;
             export const isKey = (v: unknown): v is key =>
                 typeof v === "string" || typeof v === "number" || typeof v === "symbol";
             export const isString = (v: unknown): v is string =>
                 typeof v === "string";
             export const isNotNull = <T>(v: T): v is NonNullable<T> => v !== null && v !== undefined;
             export const each = <T extends object>(obj: T, cb: <X extends Extract<keyof T, string>>(v: NonNullable<T[X]>, k: X) => void) =>
                 (Object.keys(obj) as (Extract<keyof T, string>)[])
                     .forEach(k => {
                         const v = obj[k];
                         isNotNull(v) && cb(v, k);
                     });
             export const argumentNotNull = (arg: unknown, name: string) => {
                 if (arg === null || arg === undefined)
                     throw new Error("The argument " + name + " can't be null or undefined");
             };
             export const isPromise = <T = unknown>(val: unknown): val is PromiseLike<T> =>
                 isNotNull(val) && typeof (val as PromiseLike<T>).then === "function";
             export const isDestroyable = (d: unknown): d is IDestroyable =>
                 isNotNull(d) && typeof (d as IDestroyable).destroy === "function";
             let _nextOid = 0;
             const _oid = typeof Symbol === "function" ?
                 Symbol.for("__implab__oid__") :
                 "__implab__oid__";
             type OidSlot = { [k in typeof _oid]?: string };
             export const oid = <T extends object>(instance: T): string => {
                 argumentNotNull(instance, "instance");
                 const val = (instance as OidSlot)[_oid];
                 return val ? val : ((instance as OidSlot)[_oid] = `oid_${++_nextOid}`);
             };

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 {
                 foo = "foo";
             }
             class Bar {
                 bar = "bar";
                 constructor(foo?: () => Foo) { }
             }
             interface Services {
                 foo: Foo;
                 bar?: Bar;
                 baz: Foo;
+                container: string;
             }
             interface ServicesB {
                 // will give errors
                 // baz: Bar;
                 baz: Foo;
                 zoo?: Foo;
             }
             declare const resolver: Resolver<Services>;
             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 },
                ooz: "bar"
             });
             interface SharedServices {
                 foo: Foo;
                 bar?: Bar;
                 baz: Bar;
             }
             const config = fluent()
                 .declare<Services>()
                 .declare<ServicesB>()
                 .register({
+                    zoo: it => {},
                     bar: it => it
                         .lifetime("context") // тип активации, время жизни
                         .wants({
                             zoo: "zoo", // зависимость
                             bar: "bar",
                             $zoo: { name: "foo", lazy: true, } // отложенная активация,
                             //фабричный метод
                         })
                         .wants({
                             zoom: "bar"
                         })
                         .factory(({ $zoo, zoo }) => // фабрика получает объект с именованными зависимостями
                             // удобно для деструктурирования
                             new Bar($zoo) // создается экземпляр сервиса
                         ),
                     foo: it => it.factory(() => new Foo()),
                     baz: it => it.value(new Foo())
                 })
                 .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