implab/implabjs-core Commit - r119:86e3aa3c3eea

configuration draft-1

cin -

r119:86e3aa3c3eea ioc ts support

parent child

Context file:

r119:86e3aa3c3eea

Collapse all files

src/test/ts/mock/services.ts created 644 +23 0

			@@ -0,0 +1,23
		1	import { Foo } from "./Foo";
		2	import { Bar } from "./Bar";
		3	import { Box } from "./Box";
		4	import { declare } from "../di/Annotations";
		5
		6	/**
		7	* Сервисы доступные внутри контейнера
		8	*/
		9	export interface Services {
		10	foo: Foo;
		11
		12	bar: Bar;
		13
		14	box: Box<Bar>;
		15
		16	host: string;
		17
		18	}
		19
		20	/**
		21	* Экспортируем вспомогательные функции для описания сервисов и кинфогурации
		22	*/
		23	export const { define, dependency, config } = declare<Services>();

src/main/ts/di/Annotations.ts +25 -25

-             import { Constructor } from "../interfaces";
-             import { primitive } from "../safe";
+             import { TypeRegistration } from "./Configuration";
              export interface InjectOptions {
                  lazy?: boolean;
              }
-             interface Dependency<K extends keyof any> {
+             export interface Dependency<K extends keyof any> {
                  $dependency: K;
                  lazy?: boolean;
              }
-             interface Lazy<K extends keyof any> extends Dependency<K> {
+             export interface Lazy<K extends keyof any> extends Dependency<K> {
                  lazy: true;
              }
-             type Compatible<T1, T2> = T1 extends T2 ? any : never;
+             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> :
                  WalkDependencies<D, S>;
              type WalkDependencies<D, S> = D extends primitive ? D :
                  { [K in keyof D]: ExtractDependency<D[K], S> };
-             interface Services<S> {
-                 get<K extends keyof S>(name: K): Dependency<K>;
-                 lazy<K extends keyof S>(name: K): Lazy<K>;
-                 build<T extends object>(): Builder<T, S>;
+             }
-             export declare function services<S extends object>(): Services<S>;
-             export declare function build<T = never, S = any>(): Builder<T, S>;
              export class Builder<T, S> {
-                 consume<P extends any[]>(...args: P) {
+                 declare<P extends any[]>(...args: P) {
                      return <C extends new (...args: ExtractDependency<P, S>) => T>(constructor: C) => {
+                         return constructor as C & { service: Builder<T, S> };
                      };
                  }
                  inject<P extends any[]>(...args: P) {
                      // K = "bar"
                      // M = "setValue"
                      // S[K] = Bar
                      // T[M] = (value: string) => void
                      // P[m] = (value: V) => void
                      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]>>
                      ) => {
                      };
                  }
-                 cast<T2 extends T>(): Builder<T2, S> {
-                     return this as Builder<T2, S>;
+                 }
-                 get<K extends keyof S>(name: K): Dependency<K> {
+                 getDescriptor(): TypeRegistration<T, any, S> {
                      throw new Error();
                  }
-                 lazy<K extends keyof S>(name: K): Lazy<K> {
-                     throw new Error();
+                 }
+             }
+             interface Declaration<S> {
+                 define<T>(): Builder<T, S>;
+                 dependency<K extends keyof S>(name: K, opts: { lazy: true }): Lazy<K>;
+                 dependency<K extends keyof S>(name: K, opts?: any): Dependency<K>;
+                 config(): Config<S>;
+             }
+             interface ServiceModule<T, S> {
+                 service: Builder<T, S>;
+             }
+             interface Config<S> {
+                 register<K extends keyof S>(name: K, builder: Builder<S[K], S>): Config<Omit<S, K>>;
+                 register<K extends keyof S>(name: K, m: Promise<ServiceModule<S[K], S>>): Config<Omit<S, K>>;
              }
+             export declare function declare<S extends object>(): Declaration<S>;

src/test/ts/mock/Bar.ts +5 -5

              import { Foo } from "./Foo";
-             import { build } from "./config";
+             import { define, dependency } from "./services";
-             const service = build<Bar>();
+             export const service = define<Bar>();
-             @service.consume({
-                 foo: service.get("foo"),
+             @service.declare({
+                 foo: dependency("foo"),
                  nested: {
-                     lazy: service.lazy("foo")
+                     lazy: dependency("foo", {lazy: true})
                  }
              })
              export class Bar {
                  barName = "bar";
                  _v: Foo | undefined;
                  constructor(_opts?: {
                      foo?: Foo;
                      nested?: {
                          lazy: () => Foo
                      }
                  }) {
                      if (_opts && _opts.foo)
                          this._v = _opts.foo;
                  }
                  getFoo() {
                      if (this._v === undefined)
                          throw new Error("The foo isn't set");
                      return this._v;
                  }
              }

src/test/ts/mock/Box.ts +8 -13

-             import { services } from "../di/Annotations";
-             import { Bar } from "./Bar";
-             import { Foo } from "./Foo";
-             // declare required dependencies
-             const config = services<{
-                  bar: Bar;
-                  foo: Foo;
-             }>();
+             import { define, dependency } from "./services";
              // export service descriptor
-             export const service = config.build<Box<Bar>>();
+             // через service передается информация о типе зависимости
+             // даже если это шаблон.
+             export const service = define<Box<Bar>>();
-             @service.consume(config.get("bar"))
+             @service.declare(dependency("bar"))
              export class Box<T> {
                  private _value: T | undefined;
                  constructor(value: T) {
                      this._value = value;
                  }
-                 @service.inject( config.get("bar"))
-                 setValue(value?: T) {
+                 @service.inject(dependency("bar"))
+                 setValue(value: T) {
                      this._value = value;
                      return value;
                  }
-                 setObj(value: object) {
+                 setObj(value: any) {
                  }
                  getValue() {
                      if (this._value === undefined)
                          throw new Error("Trying to get a value from the empty box");
                      return this._value;
                  }
              }

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

		@@ -1,27 +1,6
1		import { ~~Foo~~ } from "./~~Foo~~";
2		import { Bar } from "./Bar";
3		import { Box } from "./Box";
4		import { Builder } from "../di/Annotations";
5
6		interface Services {
7		foo: Foo;
8
9		bar: Bar;
10
11		box: Box<Foo>;
12
13		host: string;
	1	import { config } from "./services";
14	2
15		}
16
17		const services = {
18		build: <T>() => {
19		return new Builder<T, Services>();
20		}
21		};
22
23		namespace services {
24
25		}
26
27		export = services;
	3	config()
	4	.register("bar", import("./Bar"))
	5	.register("box", import("./Box"))
	6	.register("foo", import("./Foo"), "Foo");

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