implab/implabjs-core Commit - r124:b58fedd83580

working on container configuration dsl

cin -

r124:b58fedd83580 ioc ts support

parent child

Context file:

r124:b58fedd83580

Collapse all files

src/main/ts/di/Annotations.ts +11 -16

             import { primitive } from "../safe";
-            import { TypeRegistration } from "./Configuration";
+            import { TypeRegistration, DependencyRegistration, LazyDependencyRegistration, Registration, StrictTypeRegistration } from "./Configuration";
             export interface InjectOptions {
                 lazy?: boolean;
             }
-            export interface Dependency<K extends keyof any> {
-                $dependency: K;
-                lazy?: boolean;
-            export interface Lazy<K extends keyof any> extends Dependency<K> {
-                lazy: true;
             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 :
             interface Declaration<S extends object> {
                 define<T>(): Builder<T, S>;
-                dependency<K extends keyof S>(name: K, opts: LazyDependencyOptions<S[K]>): Lazy<K>;
+                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]>): Dependency<K>;
+                dependency<K extends keyof S>(name: K, opts?: DependencyOptions<S[K]>): DependencyRegistration<S, K>;
+                $type<P extends any[], C extends new (...args: ExtractDependency<P, S>) => any>(target: C, ...params: P): StrictTypeRegistration<C, S>;
                 configure(): Config<S>;
             }
             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>> } | S[K]): Config<S, Exclude<Y, K>>;
+                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, C extends new (...args: any) => S[K]>(name: K, d: TypeRegistration<C, S>): 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/Configuration.ts +12 -5

                 cleanup?: ((instance: T) => void) | string;
             }
-            export interface TypeRegistration<C extends new () => any, S extends object> extends ServiceRegistration<InstanceType<C>, S> {
+            export interface TypeRegistration<C extends new (...args: any[]) => any, S extends object> extends ServiceRegistration<InstanceType<C>, S> {
                 $type: string | C;
-                params?: ConstructorParameters<C>;
+                params?: Registration<ConstructorParameters<C>, S>;
             }
-            export interface FactoryRegistration<F extends () => any, S extends object> extends ServiceRegistration<ReturnType<F>, S> {
+            export interface StrictTypeRegistration<C extends new (...args: any[]) => any, S extends object> extends ServiceRegistration<InstanceType<C>, S> {
+                $type: C;
+                params?: Registration<ConstructorParameters<C>, S>;
+            }
+            export interface FactoryRegistration<F extends (...args: any[]) => any, S extends object> extends ServiceRegistration<ReturnType<F>, S> {
                 $factory: string | F;
             }
                 lazy: true;
             }
+            type OfType<K extends keyof S, S, T> = Extract<{ [k in K]: T}, S>;
             export type Registration<T, S extends object> = T extends primitive ? T :
                 (
                     T |
                     { [k in keyof T]: Registration<T[k], S> } |
-                    TypeRegistration<new () => T, S> |
+                    TypeRegistration<new (...args: any[]) => T, S> |
-                    FactoryRegistration<() => T, S> |
+                    FactoryRegistration<(...args: any[]) => T, S> |
                     ValueRegistration<any> |
                     DependencyRegistration<S, keyof S>
                 );

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

                 nested: {
                     lazy: dependency("foo", { lazy: true })
                 },
-                host: "value"
+                host: dependency("host")
-            })
+            }, "")
             export class Bar {
                 barName = "bar";
                 _v: Foo | undefined;
-                constructor(_opts?: {
+                constructor(_opts: {
                     foo?: Foo;
                     nested?: {
                         lazy: () => Foo
                     },
                     host: string
-                }) {
+                }, s: string) {
                     if (_opts && _opts.foo)
                         this._v = _opts.foo;

src/test/ts/mock/config.ts +17 -9

@@ -1,15 +1,23
1	import { configure } from "./services";	1	import { configure, dependency, Services, $type } from "./services";
2	import { Foo } from "./Foo";	2	import { Foo } from "./Foo";
3	import { Bar } from "./Bar";	3	import { Bar } from "./Bar";
		4	import { Box } from "./Box";
		5
4		6
5	export const config = configure()	7	export const config = configure()
6	.register("bar", { $from: import("./Bar"), service: "service" })	8	.register("bar", { $from: import("./Bar"), service: "service" })
7	.register("box", { $from: import("./Box") })	9	// .register("box", { $from: import("./Box") })
8	.register("host", "example.com")	10	.register("host", "example.com")
9	.register("foo", {	11	// .registerType("bar2", Bar, [{ foo: dependency("foo"), host: "" }]);
10	$type: Foo	12	.register("bar2", $type(Bar,
11	})	13	{
12	.register("bar2", {	14	foo: $type(Foo)
13	$type: Bar,	15	.override("host", "foo.example.com")
14	params: []	16	.inject("setName", dependency("host"))
15	});	17	.activate("context"),
		18	host: ""
		19	},
		20	"")
		21	)
		22	.registerType("box", Box, dependency("bar"));
		23

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

             /**
              * Экспортируем вспомогательные функции для описания сервисов и кинфогурации
              */
-            export const { define, dependency, configure } = declare<Services>();
+            export const { define, dependency, configure, $type } = 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