implab/implabjs-core Commit - r126:142c5f6dc2b5

sync

cin -

r126:142c5f6dc2b5 ioc ts support

parent child

Context file:

r126:142c5f6dc2b5

Collapse all files

src/main/ts/di/Annotations.ts 0 -17

              import { primitive } from "../safe";
              import { TypeRegistration, DependencyRegistration, LazyDependencyRegistration, Registration, StrictTypeRegistration } from "./Configuration";
              export interface InjectOptions {
                  lazy?: boolean;
              }
              type Compatible<T1, T2> = T2 extends T1 ? any : never;
              type ExtractService<K, S> = K extends keyof S ? S[K] : K;
              type ExtractDependency<D, S> = D extends { $dependency: infer K } ?
                  D extends { lazy: true } ? () => ExtractService<K, S> : ExtractService<K, S> :
                  D extends { $type: new (...args: any[]) => infer I } ? I :
                  WalkDependencies<D, S>;
              type WalkDependencies<D, S> = D extends primitive ? D :
                  { [K in keyof D]: ExtractDependency<D[K], S> };
              export class Builder<T, S extends object> {
                  declare<P extends any[]>(...args: P) {
                      return <C extends new (...args: ExtractDependency<P, S>) => T>(constructor: C) => {
                      };
                  }
                  inject<P extends any[]>(...args: P) {
                      return <X extends { [m in M]: (...args: any) => any }, M extends keyof (T | X)>(
                          target: X,
                          memberName: M,
                          descriptor: TypedPropertyDescriptor<Compatible<(...args: ExtractDependency<P, S>) => any, T[M]>>
                      ) => {
                      };
                  }
                  getDescriptor(): TypeRegistration<new () => T, S> {
                      throw new Error();
                  }
              }
              export interface DependencyOptions<T> {
                  optional?: boolean;
                  default?: T;
              }
              export interface LazyDependencyOptions<T> extends DependencyOptions<T> {
                  lazy: true;
              }
              interface Declaration<S extends object> {
                  define<T>(): Builder<T, S>;
                  dependency<K extends keyof S>(name: K, opts: LazyDependencyOptions<S[K]>): LazyDependencyRegistration<S, K>;
                  dependency<K extends keyof S>(name: K, opts?: DependencyOptions<S[K]>): DependencyRegistration<S, K>;
                  $type<T, P extends any[], C extends new (...args: ExtractDependency<P, S>) => T>(target: C, ...params: P): StrictTypeRegistration<C, S>;
-                 configure(): Config<S>;
              }
-             type ServiceModule<T, S extends object, M extends string = "service"> = {
-                 [m in M]: Builder<T, S>;
-             };
-             type PromiseOrValue<T> = PromiseLike<T> | T;
-             export interface Config<S extends object, Y extends keyof S = keyof S> {
-                 register<K extends Y>(name: K, m: { $from: Promise<ServiceModule<S[K], S>> }): Config<S, Exclude<Y, K>>;
-                 register<K extends Y, M extends string>(name: K, m: { $from: Promise<ServiceModule<S[K], S, M>>, service: M }): Config<S, Exclude<Y, K>>;
-                 register<K extends Y>(name: K, m: Registration<S[K], S>): Config<S, Exclude<Y, K>>;
-                 registerType<K extends Y, P extends any[]>(
-                     name: K, $type: new (...args: ExtractDependency<P, S>) => S[K], ...params: P): Config<S, Exclude<Y, K>>;
+             }
              export declare function declare<S extends object>(): Declaration<S>;

src/main/ts/di/fluent/interfaces.ts +9 0

              import { primitive } from "../../safe";
              import { ActivationType } from "../interfaces";
+             import { Builder } from "../Annotations";
              type ExtractService<K, S> = K extends keyof S ? S[K] : K;
              type ExtractDependency<D, S> = D extends { $dependency: infer K } ?
                  D extends { lazy: true } ? () => ExtractService<K, S> : ExtractService<K, S> :
                  D extends { $type: new (...args: any[]) => infer I } ? I :
                  D extends { $factory: (...args: any[]) => infer R } ? R :
                  WalkDependencies<D, S>;
              type WalkDependencies<D, S> = D extends primitive ? D :
                  { [K in keyof D]: ExtractDependency<D[K], S> };
+             type ServiceModule<T, S extends object, M extends keyof any = "service"> = {
+                 [m in M]: Builder<T, S>;
+             };
+             type PromiseOrValue<T> = T | PromiseLike<T>;
              export interface TypeBuilder<T, S extends object> {
                  type<P extends any[], C extends new (...args: ExtractDependency<P, S>) => T>(
                      target: C, ...params: P): ConstructorBuilder<C, S>;
                  factory<P extends any[], F extends (...args: ExtractDependency<P, S>) => T>(
                      target: F, ...params: P): FactoryBuilder<F, S>;
+                 wire<M extends keyof any>(module: PromiseOrValue<ServiceModule<T, S, M>>, m: M): ServiceBuilder<T, S>;
+                 wire(module: PromiseOrValue<ServiceModule<T, S>>): ServiceBuilder<T, S>;
              }
              export interface ServiceBuilder<T, S extends object> {
                  override<K extends keyof S>(name: K, builder: S[K] | ((t: TypeBuilder<S[K], S>) => any)): this;
                  activate(activation: ActivationType): this;
                  inject<M extends keyof T, P extends any[]>(member: T[M] extends (...params: ExtractDependency<P, S>) => any ? M : never, ...params: P): this;
              }
              export interface ConstructorBuilder<C extends new (...args: any[]) => any, S extends object> extends ServiceBuilder<InstanceType<C>, S> {
                  $type: C;
              }
              export interface FactoryBuilder<F extends (...args: any[]) => any, S extends object> extends ServiceBuilder<ReturnType<F>, S> {
                  $factory: F;
              }
              export interface ConfigBuilder<S extends object, Y extends keyof S = keyof S> {
                  register<K extends Y>(name: K, builder: S[K] | ((t: TypeBuilder<S[K], S>) => any)): ConfigBuilder<S, Exclude<Y, K>>;
              }

src/test/ts/mock/config.ts +5 -3

              import { configure, dependency, Services, $type } from "./services";
              import { Foo } from "./Foo";
              import { Bar } from "./Bar";
              import { Box } from "./Box";
-             import { declare } from "../di/Annotations";
              import { ConfigBuilder, TypeBuilder } from "../di/fluent/interfaces";
              export declare function build<T>(): TypeBuilder<T, Services>;
              export declare const config: ConfigBuilder<Services>;
              config
-                 //.register("bar", { $from: import("./Bar"), service: "service" })
-                 // .register("box", { $from: import("./Box") })
+                 .register("bar", s => s
+                     .wire(import("./Bar"), "service")
+                     .inject("setName", "heell")
+                 )
+                 .register("box", s => s.wire(import("./Box")))
-                 .register("host", "example.com")
                  // .registerType("bar2", Bar, [{ foo: dependency("foo"), host: "" }]);
                  .register("bar2", s => s.type(Bar,
                      {
                          foo: build().type(Foo)
                              .activate("context"),
                          nested: { lazy: dependency("foo", {lazy: true}) },
                          host: dependency("host")
                      },
                      "")
                      .inject("setName", dependency("host"))
                  )
                  .register("box", s => s
                      .type(Box, dependency("bar"))
                      .activate("context")
                  );

src/test/ts/mock/services.ts +1 -1

              import { Foo } from "./Foo";
              import { Bar } from "./Bar";
              import { Box } from "./Box";
              import { declare } from "../di/Annotations";
              /**
               * Сервисы доступные внутри контейнера
               */
              export interface Services {
                  foo: Foo;
                  bar: Bar;
                  bar2: Bar;
                  box: Box<Bar>;
                  host: string;
              }
              /**
               * Экспортируем вспомогательные функции для описания сервисов и кинфогурации
               */
-             export const { define, dependency, configure, $type } = declare<Services>();
+             export const { define, dependency } = declare<Services>();

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