implab/implabjs-core Commit - r111:33420a95f637

Working on IoC container configuration

cin -

r111:33420a95f637 ioc ts support

parent child

Context file:

r111:33420a95f637

Collapse all files

src/main/ts/di/Annotations.ts +6 -19

              type Setter<T = any> = (v: T) => void;
-             type Injector<T> = {
-                 [k in keyof T]: Setter;
-             };
              type Compatible<T1, T2> = T1 extends T2 ? any : never;
              type SetterType<T> = T extends (v: infer V) => void ? V : never;
-             type Tuple<T = any> = Parameters<(...args: T[]) => void>;
+             type ExtractService<K, S> = K extends keyof S ? S[K] : K;
-             interface Newable<A extends Tuple, T> {
-                 new (...params: A): T;
-                 prototype: T;
+             }
+             type ExtractDependency<D, S> = D extends { $dependency: infer K } ? D extends { lazy: true } ? () => ExtractService<K, S> : ExtractService<K, S> : VisitDependency<D, S>;
-             type MapTuple<T, A extends (keyof T)[]> = { [K in keyof A] : K extends number ? T[ A[K] ] : A[K] };
+             type VisitDependency<D, S> = D extends {} ? { [K in keyof D]: ExtractDependency<D[K], S> } : D;
              export class Builder<T, S> {
-                 provides() {
-                     return <C extends Constructor<T>>(constructor: C) => {
-                         return constructor;
+                 consume<P extends any[]>(...args: P) {
+                     return <C extends new (...args: ExtractDependency<P, S>) => T>(constructor: C) => {
+                         // return constructor;
                      };
                  }
                      };
                  }
-                 dependencies<D extends (keyof S)[]>(...deps: D) {
-                     return <C extends Constructor<T>>(constructor: MapTuple<S, D> extends ConstructorParameters<C> ? C : never) => {
-                         return constructor;
-                     } ;
                  }
+             }

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

                   * can be activated and manages the active state of the
                   * component
                   */
-                 setActivationController(controller: IActivationController);
+                 setActivationController(controller: IActivationController): void;
                  /**
                   * Gets the current activation controller for this component

src/test/ts/mock/Bar.ts +23 -8

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

src/test/ts/mock/Box.ts +3 -4

              import { config } from "./config";
-             const service = config.service("barBox");
+             const service = config.build("barBox");
-             @service.provides()
+             @service.consume(config.dependency("bar"))
              export class Box<T> {
                  private _value: T | undefined;
                      this._value = value;
                  }
-                 @service.inject("foo")
                  setObj(value: object) {
                  }
                      return this._value;
                  }
-             }
  No newline at end of file
+             }

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

              export class Foo {
-                 name = "foo";
+                 fooName = "foo";
              }

src/test/ts/mock/config.ts +39 -1

		@@ -8,8 +8,27 interface RegistrationOptions {
8	8	activation?: ActivationType;
9	9	}
10	10
	11	interface Dependency<K extends keyof any> {
	12	$dependency: K;
	13
	14	lazy?: boolean;
	15	}
	16
	17	interface Lazy<K extends keyof any> extends Dependency<K> {
	18	lazy: true;
	19	}
	20
	21	type PromiseOrValue<T> = T \| PromiseLike<T>;
	22
11	23	interface ConfigBuilder<S> {
12		~~service~~<K extends keyof S>(name: K): Builder<S[K], S>;
	24	build<K extends keyof S, T = S[K]>(name: K): Builder<T, S>;
	25
	26	dependency<K extends keyof S>(name: K): Dependency<K>;
	27
	28	lazy<K extends keyof S>(name: K): Lazy<K>;
	29
	30	mapTo<K extends keyof S>(name: K, ctor: () => PromiseOrValue<new (...args: any[]) => S[K]>): ConfigBuilder<S>;
	31
13	32	}
14	33
15	34	interface ContainerServices {
		@@ -26,4 +45,23 interface ContainerServices {
26	45	timeout: number;
27	46	}
28	47
	48	declare function load<M, C extends keyof M>(m: PromiseLike<M>, name: C): () => PromiseLike<M[C]>;
	49
	50	const t = {
	51	barBox: load(import("./Box"), "Box"),
	52
	53	foo: async () => (await import("./Bar")).Bar,
	54
	55	bar: Bar,
	56
	57	password: String,
	58
	59	user: String,
	60
	61	timeout: Number
	62	};
	63
29	64	export declare const config: ConfigBuilder<ContainerServices>;
	65	config
	66	.mapTo("bar", )
	67	.mapTo("barBox", ;

src/test/ts/tests/ContainerTests.ts +1 -1

                  const b1 = container.resolve("bar") as Bar;
                  t.assert(!isNull(b1), "bar should not be null");
-                 t.assert(!isNull(b1.foo), "bar.foo should not be null");
+                 t.assert(!isNull(b1._v), "bar.foo should not be null");
              });

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