implab/implabjs-core Commit - r127:850cc60b6e2a

fluent configuration interfaces

cin -

r127:850cc60b6e2a ioc ts support

parent child

Context file:

r127:850cc60b6e2a

Collapse all files

src/main/ts/di/Annotations.ts +5 -42

@@ -1,62 +1,25
1	import { ~~primitive~~ } from ".~~./safe~~";	1	import { TypeRegistration } from "./Configuration";
2	import { TypeRegistration, DependencyRegistration, LazyDependencyRegistration, Registration, StrictTypeRegistration } from "./Configuration";	2	import { ExtractDependency } from "./fluent/interfaces";
3
4	export interface InjectOptions {
5	lazy?: boolean;
6	}
7
8	type Compatible<T1, T2> = T2 extends T1 ? any : never;
9
10	type ExtractService<K, S> = K extends keyof S ? S[K] : K;
11		3
12	type ExtractDependency<D, S> = D extends { $dependency: infer K } ?	4	export class AnnotaionBuilder<T, S extends object> {
13	D extends { lazy: true } ? () => ExtractService<K, S> : ExtractService<K, S> :	5	wire<P extends any[]>(...args: P) {
14	D extends { $type: new (...args: any[]) => infer I } ? I :
15	WalkDependencies<D, S>;
16
17	type WalkDependencies<D, S> = D extends primitive ? D :
18	{ [K in keyof D]: ExtractDependency<D[K], S> };
19
20	export class Builder<T, S extends object> {
21	declare<P extends any[]>(...args: P) {
22	return <C extends new (...args: ExtractDependency<P, S>) => T>(constructor: C) => {	6	return <C extends new (...args: ExtractDependency<P, S>) => T>(constructor: C) => {
23		7
24	};	8	};
25	}	9	}
26		10
27	inject<P extends any[]>(...args: P) {	11	inject<P extends any[]>(...args: P) {
28	return <X extends { [m in M]: (...args: any) => any }, M extends keyof (T \| X)>(	12	return <X extends { [m in M]: (...args: any) => any }, M extends keyof (T \| X)>(
29	target: X,	13	target: X,
30	memberName: M,	14	memberName: M,
31	descriptor: TypedPropertyDescriptor<~~Compatible~~<(...args: ExtractDependency<P, S>) => any, T[M]>>	15	descriptor: TypedPropertyDescriptor< T[M] extends ((...args: ExtractDependency<P, S>) => any) ? any : never >
32	) => {	16	) => {
33		17
34	};	18	};
35	}	19	}
36		20
37	getDescriptor(): TypeRegistration<new () => T, S> {	21	getDescriptor(): TypeRegistration<new () => T, S> {
38	throw new Error();	22	throw new Error();
39	}	23	}
40		24
41	}	25	}
42
43	export interface DependencyOptions<T> {
44	optional?: boolean;
45	default?: T;
46	}
47
48	export interface LazyDependencyOptions<T> extends DependencyOptions<T> {
49	lazy: true;
50	}
51
52	interface Declaration<S extends object> {
53	define<T>(): Builder<T, S>;
54
55	dependency<K extends keyof S>(name: K, opts: LazyDependencyOptions<S[K]>): LazyDependencyRegistration<S, K>;
56	dependency<K extends keyof S>(name: K, opts?: DependencyOptions<S[K]>): DependencyRegistration<S, K>;
57
58	$type<T, P extends any[], C extends new (...args: ExtractDependency<P, S>) => T>(target: C, ...params: P): StrictTypeRegistration<C, S>;
59	}
60
61
62	export declare function declare<S extends object>(): Declaration<S>;

src/main/ts/di/fluent/interfaces.ts +37 -16

             import { primitive } from "../../safe";
             import { ActivationType } from "../interfaces";
-            import { Builder } from "../Annotations";
+            import { AnnotaionBuilder } from "../Annotations";
+            import { LazyDependencyRegistration, DependencyRegistration } from "../Configuration";
+            import { PromiseOrValue } from "../../interfaces";
-            type ExtractService<K, S> = K extends keyof S ? S[K] : K;
+            export interface DependencyOptions<T> {
+                optional?: boolean;
+                default?: T;
+            }
-            type ExtractDependency<D, S> = D extends { $dependency: infer K } ?
+            export interface LazyDependencyOptions<T> extends DependencyOptions<T> {
+                lazy: true;
+            }
+            export type ExtractService<K, S> = K extends keyof S ? S[K] : K;
+            export 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 :
+            export 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"> = {
+            export type ServiceModule<T, S extends object, M extends keyof any = "service"> = {
-                [m in M]: Builder<T, S>;
+                [m in M]: AnnotaionBuilder<T, S>;
             };
-            type PromiseOrValue<T> = T | PromiseLike<T>;
+            export interface ServiceBuilder<T, S extends object> {
-            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>;
+                wired<M extends keyof any>(module: PromiseOrValue<ServiceModule<T, S, M>>, m: M): RegistrationBuilder<T, S>;
-                wire(module: PromiseOrValue<ServiceModule<T, S>>): ServiceBuilder<T, S>;
+                wired(module: PromiseOrValue<ServiceModule<T, S>>): RegistrationBuilder<T, S>;
             }
-            export interface ServiceBuilder<T, S extends object> {
+            export interface RegistrationBuilder<T, S extends object> {
-                override<K extends keyof S>(name: K, builder: S[K] | ((t: TypeBuilder<S[K], S>) => any)): this;
+                override<K extends keyof S>(name: K, builder: S[K] | ((t: ServiceBuilder<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> {
+            export interface ConstructorBuilder<C extends new (...args: any[]) => any, S extends object> extends RegistrationBuilder<InstanceType<C>, S> {
                 $type: C;
             }
-            export interface FactoryBuilder<F extends (...args: any[]) => any, S extends object> extends ServiceBuilder<ReturnType<F>, S> {
+            export interface FactoryBuilder<F extends (...args: any[]) => any, S extends object> extends RegistrationBuilder<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>>;
+                register<K extends Y>(name: K, builder: S[K] | ((t: ServiceBuilder<S[K], S>) => any)): ConfigBuilder<S, Exclude<Y, K>>;
             }
+            interface ServicesDeclaration<S extends object> {
+                build<T>(this: void): ServiceBuilder<T, S>;
+                annotate<T>(this: void): AnnotaionBuilder<T, S>;
+                dependency<K extends keyof S>(this: void, name: K, opts: LazyDependencyOptions<S[K]>): LazyDependencyRegistration<S, K>;
+                dependency<K extends keyof S>(this: void, name: K, opts?: DependencyOptions<S[K]>): DependencyRegistration<S, K>;
+                configure(): ConfigBuilder<S>;
+            }
+            export declare function declare<S extends object>(): ServicesDeclaration<S>;

src/main/ts/interfaces.ts +2 0

             export interface Constructor<T = {}> {
                 new(...args: any[]): T;
                 prototype: T;
             }
+            export type PromiseOrValue<T> = T | PromiseLike<T>;
             export type Factory<T = {}> = (...args: any[]) => T;
             export type Predicate<T = any> = (x: T) => boolean;
             export interface MapOf<T> {
                 [key: string]: T;
             }
             export interface IDestroyable {
                 destroy(): void;
             }
             export interface IRemovable {
                 remove(): void;
             }
             export interface ICancellation {
                 throwIfRequested(): void;
                 isRequested(): boolean;
                 isSupported(): boolean;
                 register(cb: (e: any) => void): IDestroyable;
             }
             /**
              * Интерфейс поддерживающий асинхронную активацию
              */
             export interface IActivatable {
                 /**
                  * @returns Boolean indicates the current state
                  */
                 isActive(): boolean;
                 /**
                  * Starts the component activation
                  * @param ct cancellation token for this operation
                  */
                 activate(ct?: ICancellation): Promise<void>;
                 /**
                  * Starts the component deactivation
                  * @param ct cancellation token for this operation
                  */
                 deactivate(ct?: ICancellation): Promise<void>;
                 /**
                  * Sets the activation controller for this component
                  * @param controller The activation controller
                  *
                  * Activation controller checks whether this component
                  * can be activated and manages the active state of the
                  * component
                  */
                 setActivationController(controller: IActivationController): void;
                 /** Indicates whether this component has an activation controller */
                 hasActivationController(): boolean;
                 /**
                  * Gets the current activation controller for this component
                  */
                 getActivationController(): IActivationController;
             }
             export interface IActivationController {
                 activating(component: IActivatable, ct?: ICancellation): Promise<void>;
                 activated(component: IActivatable, ct?: ICancellation): Promise<void>;
                 deactivating(component: IActivatable, ct?: ICancellation): Promise<void>;
                 deactivated(component: IActivatable, ct?: ICancellation): Promise<void>;
                 deactivate(ct?: ICancellation): Promise<void>;
                 activate(component: IActivatable, ct?: ICancellation): Promise<void>;
                 hasActive(): boolean;
                 getActive(): IActivatable;
             }
             export interface IAsyncComponent {
                 getCompletion(): Promise<void>;
             }
             export interface ICancellable {
                 cancel(reason?: any): void;
             }
             export interface IObservable<T> {
                 on(next: (x: T) => void, error?: (e: any) => void, complete?: () => void): IDestroyable;
                 next(ct?: ICancellation): Promise<T>;
             }
             export interface IObserver<T> {
                 next(event: T): void;
                 error(e: any): void;
                 complete(): void;
             }
             export interface TextWriter {
                 write(obj: any): void;
                 write(format: string, ...args: any[]): void;
                 writeLine(obj?: any): void;
                 writeLine(format: string, ...args: any[]): void;
                 writeValue(value: any, spec?: string): void;
             }

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

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

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

             import { Bar } from "./Bar";
-            import { define, dependency } from "./services";
+            import { annotate, dependency } from "./services";
             // export service descriptor
             // через service передается информация о типе зависимости
             // даже если это шаблон.
-            export const service = define<Box<Bar>>();
+            export const service = annotate<Box<Bar>>();
-            @service.declare(dependency("bar"))
+            @service.wire()
             export class Box<T> {
                 private _value: T | undefined;
-                constructor(value: T) {
+                constructor(value?: T) {
                     this._value = value;
                 }
                 @service.inject(dependency("bar"))
                 setValue(value: T) {
                     this._value = value;
                     return value;
                 }
-                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 +4 -8

-            import { configure, dependency, Services, $type } from "./services";
+            import { configure, dependency, build } from "./services";
             import { Foo } from "./Foo";
             import { Bar } from "./Bar";
             import { Box } from "./Box";
-            import { ConfigBuilder, TypeBuilder } from "../di/fluent/interfaces";
-            export declare function build<T>(): TypeBuilder<T, Services>;
+            export const config = configure()
-            export declare const config: ConfigBuilder<Services>;
-            config
                 .register("bar", s => s
-                    .wire(import("./Bar"), "service")
+                    .wired(import("./Bar"), "service")
                     .inject("setName", "heell")
                 )
-                .register("box", s => s.wire(import("./Box")))
+                .register("box", s => s.wired(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 +2 -2

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