implab/implabjs-core Commit - r132:0866c6259285

working on fluent configuration

cin -

r132:0866c6259285 ioc ts support

parent child

Context file:

r132:0866c6259285

Collapse all files

src/main/ts/di/fluent/ConfigBuilder.ts created 644 +17 0

@@ -0,0 +1,17
	1	import { Container } from "../Container";
	2	import { ExtractDependency, ServiceRecordBuilder } from "./interfaces";
	3
	4	export class ConfigBuilder<S extends object, Y extends keyof S = keyof S> {
	5	register<K extends Y>(name: K, builder: (t: ServiceRecordBuilder<S[K], S>) => void \| Promise<void>): ConfigBuilder<S, Exclude<Y, K>>;
	6	register<K extends Y, V>(name: S[K] extends ExtractDependency<V, S> ? K : never, value: V): ConfigBuilder<S, Exclude<Y, K>>;
	7	register<K extends Y>(name: K, value: S[K], raw: true): ConfigBuilder<S, Exclude<Y, K>>;
	8	register<K extends Y>(name: K, value: any, raw = false): ConfigBuilder<S, Exclude<Y, K>> {
	9
	10	return this;
	11	}
	12
	13	apply(container: Container<S>): PromiseLike<void> {
	14
	15	return Promise.resolve();
	16	}
	17	}

src/main/ts/di/fluent/ConstructorBuiler.ts created 644 +17 0

@@ -0,0 +1,17
	1	import { RegistrationBuilder } from "./RegistrationBuilder";
	2
	3	export class ConstructorBuilder<C extends new (...args: any[]) => any, S extends object>
	4	extends RegistrationBuilder<InstanceType<C>, S> {
	5
	6	$type: C;
	7
	8	_params: any;
	9
	10	constructor(target: C, params: any) {
	11	super();
	12	this.$type = target;
	13
	14	this._params = params;
	15	}
	16
	17	}

src/main/ts/di/fluent/FactoryBuilder.ts created 644 +14 0

@@ -0,0 +1,14
	1	import { RegistrationBuilder } from "./RegistrationBuilder";
	2
	3	export class FactoryBuilder<F extends (...args: any[]) => any, S extends object> extends RegistrationBuilder<ReturnType<F>, S> {
	4	$factory: F;
	5
	6	_params: any;
	7
	8	constructor(target: F, params: any) {
	9	super();
	10
	11	this.$factory = target;
	12	this._params = params;
	13	}
	14	}

src/main/ts/di/fluent/ServiceRecordBuilder.ts created 644 0 0

NO CONTENT: new file 100644

src/main/ts/di/ActivationContext.ts +7 0

@@ -120,4 +120,11 export class ActivationContext<S extends
120	clone._service = service;	120	clone._service = service;
121	return clone;	121	return clone;
122	}	122	}
		123
		124	/** Creates a clone for the current context, used to protect it from modifications */
		125	clone(): this {
		126	const clone = Object.create(this);
		127	clone._services = Object.create(this._services);
		128	return clone;
		129	}
123	}	130	}

src/main/ts/di/Annotations.ts +5 0

             import { TypeRegistration } from "./Configuration";
             import { ExtractDependency } from "./fluent/interfaces";
+            import { RegistrationBuilder } from "./fluent/RegistrationBuilder";
             export class AnnotaionBuilder<T, S extends object> {
                 wire<P extends any[]>(...args: P) {
                     throw new Error();
                 }
+                getRegistrationBuilder(): RegistrationBuilder<T, S> {
+                    throw new Error();
+                }
             }

src/main/ts/di/Configuration.ts +17 -4

             import { ICancellation } from "../interfaces";
             import { isDescriptor } from "./traits";
             import { LazyReferenceDescriptor } from "./LazyReferenceDescriptor";
+            import { LifetimeManager } from "./LifetimeManager";
             export interface RegistrationScope<S extends object> {
                 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 |
                 _makeServiceParams(data: ServiceRegistration<any, S>) {
                     const opts: any = {
-                        owner: this._container
                     };
                     if (data.services)
                         opts.services = this._visitRegistrations(data.services, "services");
                             this._visit(data.params, "params");
                     if (data.activation) {
-                        opts.activation = data.activation;
+                        opts.activation = this._getLifetimeManager(data.activation);
                     }
                     if (data.cleanup)
                     this._leave();
                     return d;
                 }
+                _getLifetimeManager(activation: ActivationType) {
+                    switch (activation) {
+                        case "container":
+                            return this._container.getLifetimeManager();
+                        case "hierarchy":
+                            return LifetimeManager.hierarchyLifetime;
+                        case "context":
+                            return LifetimeManager.contextLifetime;
+                        case "singleton":
+                            return LifetimeManager.singletonLifetime;
+                        default:
+                            return LifetimeManager.empty;
+                    }
+                }
             }

src/main/ts/di/LazyReferenceDescriptor.ts +1 -1

                     return (cfg?: PartialServiceMap<S>) => {
                         // защищаем контекст на случай исключения в процессе
                         // активации
-                        const ct = saved.clone();
+                        const ct = cfg ? saved.clone() : saved;
                         try {
                             if (cfg) {
                                 each(cfg, (v, k) => ct.register(k, v));

src/main/ts/di/LifetimeManager.ts +5 -4

                 private _cache: MapOf<any> = {};
                 private _destroyed = false;
+                private _pending: MapOf<boolean> = {};
                 initialize(id: string): ILifetime {
                     const self = this;
-                    let pending = false;
                     return {
                         has() {
                             return (id in self._cache);
                         },
                         enter() {
-                            if (pending)
+                            if (self._pending[id])
                                 throw Error(`Cyclic reference detected: the item with the key ${id} is already activating.`);
-                            pending = true;
+                            self._pending[id] = true;
                         },
                         store(item: any, cleanup?: (item: any) => void) {
                             if (this.has())
                                 throw new Error(`The item with with the key ${id} already registered with this lifetime manager`);
-                            pending = false;
+                            delete self._pending[id];
                             self._cache[id] = item;

src/main/ts/di/ServiceDescriptor.ts 0 -7

             };
             export interface ServiceDescriptorParams<S extends object, T, P extends any[]> {
-                owner: Container<S>;
                 lifetime?: ILifetimeManager;
                 params?: P;
                 _lifetime = LifetimeManager.empty;
-                _owner: Container<S>;
                 constructor(opts: ServiceDescriptorParams<S, T, P>) {
-                    argumentNotNull(opts && opts.owner, "opts.owner");
-                    this._owner = opts.owner;
                     if (opts.lifetime)
                         this._lifetime = opts.lifetime;

src/main/ts/di/TypeServiceDescriptor.ts +5 -5

             import { ServiceDescriptor, ServiceDescriptorParams } from "./ServiceDescriptor";
-            import { Constructor, Factory } from "../interfaces";
             import { argumentNotNull, isPrimitive } from "../safe";
             export interface TypeServiceDescriptorParams<S extends object, T extends object, P extends any[]> extends ServiceDescriptorParams<S, T, P> {
-                type: Constructor<T>;
+                type: new (...args: any[]) => T;
             }
             export class TypeServiceDescriptor<S extends object, T extends object, P extends any[]> extends ServiceDescriptor<S, T, P> {
-                _type: Constructor;
+                _type: new (...args: any[]) => T;
                 constructor(opts: TypeServiceDescriptorParams<S, T, P>) {
                     super(opts);
                     if (this._params) {
                         if (this._params.length) {
                             this._factory = (...args) => {
-                                const t = Object.create(ctor.prototype);
+                                /*const t = Object.create(ctor.prototype);
                                 const inst = ctor.apply(t, args);
-                                return isPrimitive(inst) ? t : inst;
+                                return isPrimitive(inst) ? t : inst;*/
+                                return new ctor(...args);
                             };
                         } else {
                             this._factory = arg => {

src/main/ts/di/fluent/RegistrationBuilder.ts +4 -4

-            import { ServiceRecordBuilder, ExtractDependency, RegistrationVisitor } from "./interfaces";
+            import { ServiceRecordBuilder, ExtractDependency, RegistrationVisitor, ServiceRegistration } from "./interfaces";
             import { ActivationType } from "../interfaces";
-            export class RegistrationBuilder<T, S extends object> {
+            export class RegistrationBuilder<T, S extends object> implements ServiceRegistration {
                 private _activationType: ActivationType = "call";
                 private _overrides: { [m in keyof S]?: (...args: any) => void } | undefined;
                     return this;
                 }
-                visit(visitor: RegistrationVisitor<S>) {
+                visit(visitor: RegistrationVisitor) {
                 }
-            }
  No newline at end of file

src/main/ts/di/fluent/interfaces.ts +4 -21

                 wired(module: ServiceModule<T, S>): RegistrationBuilder<T, S>;
             }
-            export interface RegistrationVisitor<S extends object> {
+            export interface RegistrationVisitor {
                 visitDependency(): void;
                 visitObject(): void;
             }
-            export interface RegistrationBuilder<T, S extends object> {
+            export interface ServiceRegistration {
-                override<K extends keyof S>(name: K, builder: S[K], raw: true): this;
+                visit(visitor: RegistrationVisitor): void;
-                override<K extends keyof S>(name: K, builder: (t: ServiceRecordBuilder<S[K], S>) => void): this;
-                override<K extends keyof S, V>(name: S[K] extends ExtractDependency<V, S> ? K : never, value: V): 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;
-                visit(visitor: RegistrationVisitor<S>): void;
-            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 RegistrationBuilder<ReturnType<F>, S> {
-                $factory: F;
             }
             export interface ConfigBuilder<S extends object, Y extends keyof S = keyof S> {
                 apply(container: Container<S>): Promise<void>;
             }
-            interface ServicesDeclaration<S extends object> {
+            export interface ServicesDeclaration<S extends object> {
                 build<T>(this: void): ServiceRecordBuilder<T, S>;
                 annotate<T>(this: void): AnnotaionBuilder<T, S>;
                 configure(): ConfigBuilder<S>;
             }
-            export declare function declare<S extends object>(): ServicesDeclaration<S>;

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

                 enter(): void;
                 store(item: any, cleanup?: (item: any) => void): void;
-            }
  No newline at end of file

src/main/ts/di/traits.ts +44 -1

@@ -1,7 +1,50
1	import { isPrimitive } from "../safe";	1	import { isPrimitive } from "../safe";
2	import { Descriptor } from "./interfaces";	2	import { Descriptor } from "./interfaces";
		3	import { ServicesDeclaration, ServiceRecordBuilder, ServiceModule, RegistrationBuilder, ExtractDependency } from "./fluent/interfaces";
		4	import { AnnotaionBuilder } from "./Annotations";
		5	import { FactoryBuilder } from "./fluent/FactoryBuilder";
		6	import { ConstructorBuilder } from "./fluent/ConstructorBuiler";
3		7
4	export function isDescriptor(x: any): x is Descriptor {	8	export function isDescriptor(x: any): x is Descriptor {
5	return (!isPrimitive(x)) &&	9	return (!isPrimitive(x)) &&
6	(x.activate instanceof Function);	10	(x.activate instanceof Function);
7	} No newline at end of file	11	}
		12
		13	export function declare<S extends object>(): ServicesDeclaration<S> {
		14	return {
		15	annotate<T>() {
		16	return new AnnotaionBuilder<T, S>();
		17	},
		18	build<T>(): ServiceRecordBuilder<T, S> {
		19	return {
		20	factory<P extends any[], F extends (...args: ExtractDependency<P, S>) => T>(
		21	target: F,
		22	...params: P
		23	): FactoryBuilder<F, S> {
		24	return new FactoryBuilder(target, params);
		25	},
		26
		27	type<P extends any[], C extends new (...args: ExtractDependency<P, S>) => T>(
		28	target: C, ...params: P
		29	): ConstructorBuilder<C, S> {
		30	return new ConstructorBuilder(target, params);
		31	},
		32
		33	wired<M extends keyof any>(module: ServiceModule<T, S, M>, m?: M): RegistrationBuilder<T, S> {
		34	const service = m ?
		35	module[m] :
		36	(module as ServiceModule<T, S>).service;
		37	if (!service)
		38	throw new Error("The specified module doen's provides a service annotation");
		39	return service.getRegistrationBuilder();
		40	}
		41	};
		42	},
		43	configure() {
		44	throw new Error();
		45	},
		46	dependency() {
		47	throw new Error();
		48	}
		49	};
		50	}

src/main/ts/log/writers/ConsoleWriter.ts +1 -1

	@@ -1,1 +1,1
	1	export { ConsoleLogger as ConsoleWriter } from "./ConsoleLogger"; No newline at end of file		1	export { ConsoleLogger as ConsoleWriter } from "./ConsoleLogger";

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