implab/implabjs-di Commit - r2:154d88dba49c

code comments

cin -

r2:154d88dba49c default

parent child

Context file:

r2:154d88dba49c

Collapse all files

src/main/ts/FluentConfiguration.ts +32 -5

              import { DescriptorBuilder } from "./DescriptorBuilder";
-             import { ConfigurableKeys, ContainerServices, ConfigurableServices, RegistrationBuildersMap, RequiredKeys } from "./interfaces";
+             import { ConfigurableKeys, ContainerServices, ConfigurableServices, RegistrationBuildersMap, ExtractRequired } from "./interfaces";
              import { ServiceContainer } from "./interfaces";
              import { argumentNotNull, each, isKey } from "./traits";
              export class FluentConfiguration<S extends object, Y extends ConfigurableKeys<S> = ConfigurableKeys<S>> {
-                 _builders: Partial<RegistrationBuildersMap<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>> {
                      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>>;
                  }
-                 done(missing: RequiredKeys<S, Y> extends never ? void : RequiredKeys<S, Y>) {
-                     if (missing !== undefined)
-                         throw new Error("The configuration isn't complete");
+                 /**
+                  * 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;
                  }
                  apply<A extends Partial<S>>(target: ServiceContainer<A>) {
                      let pending = 1;
                      const _t2 = target as ServiceContainer<S>;
                      const reject = (ex: unknown) => { throw ex; };
                      const complete = () => !--pending;
                      each(this._builders, (v, k) => {
                          pending++;
                          const d = new DescriptorBuilder<ContainerServices<S>, NonNullable<ConfigurableServices<S>[typeof k]>>(_t2,
                              result => {
                                  _t2.register(k, result);
                                  complete();
                              },
                              reject
                          );
                          v(d);
                      });
                      if (!complete())
                          throw new Error("The configuration didn't complete.");
                      return _t2 as ServiceContainer<A & S>;
                  }
              }

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

              import { ActivationContext } from "./ActivationContext";
              export type primitive = number | string | null | undefined | symbol;
              export interface IDestroyable {
                  destroy(): void;
              }
              /**
               * @template S Карта доступных зависимостей
               */
              export interface Resolver<S extends object> {
                  /**
                   * Функция для разрешения зависимостей, поддерживает создание фабричных методов,
                   * отложенную активацию и значение по-умолчанию для сервисов
                   * @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 interface DescriptorBuilder<S extends object, T> {
                  /**
                   *
                   * @param f
                   */
                  factory(f: (resolve: Resolver<S>) => T): void;
                  override<K extends ConfigurableKeys<S>>(name: K, builder: RegistrationBuilder<S, NonNullable<S[K]>>): this;
                  override<K extends ConfigurableKeys<S>>(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;
                  value(v: T): void;
              }
              export type RegistrationBuilder<S extends object, T> = (d: DescriptorBuilder<S, T>) => void;
              export type RegistrationBuildersMap<S extends object, K extends ConfigurableKeys<S> = ConfigurableKeys<S>> = {
                  [k in K]-?: RegistrationBuilder<ContainerServices<S>, NonNullable<ConfigurableServices<S>[k]>>
              };
              export interface Descriptor<S extends object, T> {
                  activate(context: ActivationContext<S>): T;
              }
              export type ConfigurableDescriptor<S extends object, K extends ConfigurableKeys<S>> = Descriptor<ContainerServices<S>, ConfigurableServices<S>[K]>;
              export type RegistrationMap<S extends object, K extends keyof S = keyof S> = {
                  [k in K]-?: Descriptor<S, S[k]>;
              };
              export interface ProvidedServices<S extends object> {
                  container: ServiceLocator<ContainerServices<S>>;
                  childContainer: ServiceContainer<S>;
              }
              export type ProvidedKeys = keyof ProvidedServices<object>;
              export type ContainerKeys<S extends object> = keyof ContainerServices<S>;
              export type Mix<S, X> = { [k in keyof (S & X)]: k extends keyof X ? X[k] : S[k & keyof S] };
              export type ContainerServices<S extends object> = Mix<S, ProvidedServices<S>>;
              export type ConfigurableKeys<S extends object> = Exclude<keyof S, ProvidedKeys>;
              export type ConfigurableServices<S extends object> = Pick<S, ConfigurableKeys<S>>;
              export interface ServiceLocator<S extends object> {
                  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 object> extends ServiceLocator<ContainerServices<S>>, LifetimeContainer, IDestroyable {
                  register<K extends ConfigurableKeys<S>>(name: K, service: ConfigurableDescriptor<S, K>): void;
                  register<K extends ConfigurableKeys<S>>(services: { [k in K]: ConfigurableDescriptor<S, K> }): void;
                  createChildContainer(): ServiceContainer<S>;
              }
              export type ActivationType = "singleton" | "container" | "hierarchy" | "context" | "call";
              /**
               * Интерфейс для управления жизнью экземпляра объекта. Каждая регистрация имеет
               * свой собственный объект `ILifetime`, который создается при первой активации
               */
              export interface ILifetime<T> {
                  /** Проверяет, что уже создан экземпляр объекта */
                  has(): boolean;
                  get(): T;
                  initialize(context: ActivationContext<object>): void;
                  store(item: T, cleanup?: (item: T) => void): void;
              }
-             export type RequiredKeys<T, K extends keyof T = keyof T> = keyof { [p in K as (T[p] extends undefined ? never : p)]-?: T[p] };
+             export type ExtractRequired<T, K extends keyof T = keyof T> = { [p in K as (undefined extends T[p] ? never : p)]-?: T[p] };

src/test/ts/t/container.ts +1 -1

              /* eslint max-classes-per-file: ["error", 20] */
              import { describe, it } from "mocha";
              import {LifetimeManager} from "../LifetimeManager";
              import {Container} from "../Container";
              import { fluent } from "../traits";
              class Foo {
                  foo = "foo";
              }
              class Bar {
                  bar = "bar";
                  constructor(foo?: () => Foo) {}
              }
              interface Services {
                  foo: Foo;
                  bar?: Bar;
                  baz: Foo;
              }
              interface ServicesB {
                  // will give errors
                  // baz: Bar;
                  baz: Foo;
                  zoo?: Foo;
              }
              interface SharedServices {
                  foo: Foo;
                  bar?: Bar;
                  baz: Bar;
              }
              const config = fluent()
                  .declare<Services>()
                  .declare<ServicesB>()
                  .register({
                      bar: it => it
                          .lifetime("context")
                          .factory($ => new Bar($("zoo", {lazy: true, default: new Foo()}))),
                      foo: it => it.factory($ => new Foo()),
                      baz: it => it.value(new Foo())
                  })
-                 .done();
+                 .done({});
                  declare const container: Container<SharedServices>;
              const c2 = config.apply(container);
              c2.resolve("baz");
  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