implab/implabjs-core Commit - r135:03e32ec7c20b

Completely removed IoC annotations...

cin -

r135:03e32ec7c20b ioc ts support

parent child

Context file:

r135:03e32ec7c20b

Collapse all files

src/main/ts/di/fluent/DescriptorImpl.ts created 644 +63 0

@@ -0,0 +1,63
	1	import { Descriptor, PartialServiceMap, ILifetime, ContainerKeys } from "../interfaces";
	2	import { ActivationContext } from "../ActivationContext";
	3	import { each } from "../../safe";
	4	import { DependencyOptions, LazyDependencyOptions, Resolver } from "./interfaces";
	5
	6	export interface DescriptorImplArgs<S extends object, T> {
	7	lifetime: ILifetime;
	8
	9	factory: (resolve: Resolver<S>) => T;
	10
	11	cleanup?: (item: T) => void;
	12
	13	overrides?: PartialServiceMap<S>;
	14	}
	15
	16	export class DescriptorImpl<S extends object, T> implements Descriptor<S, T> {
	17
	18	private readonly _overrides?: PartialServiceMap<S>;
	19
	20	private readonly _lifetime: ILifetime;
	21
	22	private readonly _factory: (resolve: Resolver<S>) => T;
	23
	24	private readonly _cleanup?: (item: T) => void;
	25
	26	constructor(args: DescriptorImplArgs<S, T>) {
	27	this._lifetime = args.lifetime;
	28	this._factory = args.factory;
	29	if (args.cleanup)
	30	this._cleanup = args.cleanup;
	31	if (args.overrides)
	32	this._overrides = args.overrides;
	33	}
	34
	35	activate(context: ActivationContext<S>): T {
	36
	37	if (this._lifetime.has())
	38	return this._lifetime.get();
	39
	40	this._lifetime.initialize(context);
	41
	42	if (this._overrides)
	43	each(this._overrides, (v, k) => context.register(k, v));
	44
	45	const resolve = (name: ContainerKeys<S>, opts?: DependencyOptions \| LazyDependencyOptions) => {
	46	if (opts && "lazy" in opts && opts.lazy) {
	47	const c2 = context.clone();
	48	return () => {
	49	return opts.optional ? c2.resolve(name, opts.default) : c2.resolve(name);
	50	};
	51	} else {
	52	return opts && opts.optional ? context.resolve(name, opts.default) : context.resolve(name);
	53	}
	54	};
	55
	56	const instance = this._factory.call(undefined, resolve);
	57
	58	this._lifetime.store(instance, this._cleanup);
	59
	60	return instance;
	61	}
	62
	63	}

src/main/ts/di/fluent/FluentConfiguration.ts created 644 +58 0

@@ -0,0 +1,58
	1	import { Container } from "../Container";
	2	import { argumentNotNull, each, isPrimitive, isPromise } from "../../safe";
	3	import { DescriptorBuilder } from "./DescriptorBuilder";
	4	import { RegistrationBuilder, FluentRegistrations } from "./interfaces";
	5	import { Cancellation } from "../../Cancellation";
	6
	7	export class FluentConfiguration<S extends object, Y extends keyof S = keyof S> {
	8
	9	_builders: { [k in keyof S]?: RegistrationBuilder<S, S[k]> } = {};
	10
	11	register<K extends Y>(name: K, builder: RegistrationBuilder<S, S[K]>): FluentConfiguration<S, Exclude<Y, K>>;
	12	register<K extends Y>(config: FluentRegistrations<K, S>): FluentConfiguration<S, Exclude<Y, K>>;
	13	register<K extends Y>(nameOrConfig: K \| FluentRegistrations<K, S>, builder?: RegistrationBuilder<S, S[K]>): FluentConfiguration<S, Exclude<Y, K>> {
	14	if (isPrimitive(nameOrConfig)) {
	15	argumentNotNull(builder, "builder");
	16	this._builders[nameOrConfig] = builder;
	17	} else {
	18	each(nameOrConfig, (v, k) => this.register(k, v));
	19	}
	20
	21	return this;
	22	}
	23
	24	apply(target: Container<S>, ct = Cancellation.none) {
	25
	26	let pending = 1;
	27
	28	return new Promise((resolve, reject) => {
	29	function guard(v: void \| Promise<void>) {
	30	if (isPromise(v))
	31	v.catch(reject);
	32	}
	33
	34	function complete() {
	35	if (!--pending)
	36	resolve();
	37	}
	38	each(this._builders, (v, k) => {
	39	pending++;
	40	const d = new DescriptorBuilder<S, any>(target,
	41	result => {
	42	target.register(k, result);
	43	complete();
	44	},
	45	reject
	46	);
	47
	48	try {
	49	guard(v(d, ct));
	50	} catch (e) {
	51	reject(e);
	52	}
	53	});
	54	complete();
	55	});
	56	}
	57
	58	}

src/test/ts/tests/FluentContainerTests.ts created 644 +54 0

@@ -0,0 +1,54
	1	import { test } from "./TestTraits";
	2	import { fluent } from "../di/traits";
	3	import { Bar } from "../mock/Bar";
	4	import { Container } from "../di/Container";
	5	import { Foo } from "../mock/Foo";
	6	import { Box } from "../mock/Box";
	7	import { delay } from "../safe";
	8
	9	test("Simple fluent config", async t => {
	10	const config = fluent<{ host: string; bar: Bar; foo: Foo }>()
	11	.register({
	12	host: it => it.value("example.com"),
	13	bar: it => it.factory(resolve => new Bar({ host: resolve("host") }, "s-bar")),
	14	foo: it => import("../mock/Foo").then(m => it.lifetime("container").factory(() => new m.Foo()))
	15	});
	16
	17	const container = new Container<{ host: string; bar: Bar; foo: Foo; }>();
	18	await config.apply(container);
	19
	20	t.equal(container.resolve("host"), "example.com", "The value should be resolved");
	21	t.assert(container.resolve("bar"), "The service should de activated");
	22	t.equal(container.resolve("foo"), container.resolve("foo"), "The service should be activated once");
	23	});
	24
	25	test("Nested async configuration", async t => {
	26	const container = await new Container<{
	27	foo: Foo;
	28	box: Box<Foo>
	29	}>().fluent({
	30	foo: it => delay(0).then(() => it.factory(() => new Foo())),
	31	box: it => it.lifetime("context").factory($dependency => new Box($dependency("foo")))
	32	});
	33
	34	t.assert(container.resolve("box").getValue(), "The dependency should be set");
	35	t.equals(container.resolve("box").getValue(), container.resolve("box").getValue(), "The service should be activated once")
	36	});
	37
	38	test("Bad fluent config", async t => {
	39	try {
	40	await new Container<{
	41	foo: Foo;
	42	box: Box<Foo>
	43	}>().fluent({
	44	foo: it => delay(0).then(() => it.factory(() => new Foo())),
	45	box: it => it.lifetime("context")
	46	.override("foo", () => { throw new Error("bad override"); })
	47	.factory($dependency => new Box($dependency("foo")))
	48	});
	49	t.fail("Should throw");
	50	} catch (e) {
	51	t.pass("The configuration should fail");
	52	t.equal(e.message, "bad override", "the error should pass");
	53	}
	54	});

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

             let nextId = 1;
+            /** This class is created once per `Container.resolve` method call and used to
+             * cache dependencies and to track created instances. The activation context
+             * tracks services with `context` activation type.
+             */
             export class ActivationContext<S extends object> {
                 _cache: MapOf<any>;
                 _parent: ActivationContext<S> | undefined;
+                /** Creates a new activation context with the specified parameters.
+                 * @param container the container which starts the activation process
+                 * @param services the initial service registrations
+                 * @param name the name of the service being activated, this parameter is
+                 *  used for the debug purpose.
+                 * @param service the service to activate, this parameter is used for the
+                 *  debug purpose.
+                 */
                 constructor(container: Container<S>, services: ContainerServiceMap<S>, name: string, service: Descriptor<S, any>) {
                     this._name = name;
                     this._service = service;
                     this._container = container;
                 }
+                /** the name of the current resolving dependency */
                 getName() {
                     return this._name;
                 }
+                /** Returns the container for which 'resolve' method was called */
                 getContainer() {
                     return this._container;
                 }
+                /** Resolves the specified dependency in the current context
+                 * @param name The name of the dependency being resolved
+                 */
                 resolve<K extends ContainerKeys<S>>(name: K): TypeOfService<S, K>;
+                /** Resolves the specified dependency with the specified default value if
+                 * the dependency is missing.
+                 *
+                 * @param name The name of the dependency being resolved
+                 * @param def A default value to return in case of the specified dependency
+                 *   is missing.
+                 */
                 resolve<K extends ContainerKeys<S>, T>(name: K, def: T): TypeOfService<S, K> | T;
+                /** Resolves the specified dependency and returns undefined in case if the
+                 * dependency is missing.
+                 *
+                 * @param name The name of the dependency being resolved
+                 */
                 resolve<K extends ContainerKeys<S>>(name: K, def: undefined): TypeOfService<S, K> | undefined;
                 resolve<K extends ContainerKeys<S>, T>(name: K, def?: T): TypeOfService<S, K> | T | undefined {
                     const d = this._services[name];
                         }
                     };
                 }
                 activate<T>(d: Descriptor<S, T>, name: string) {
                     if (trace.isLogEnabled())
                         trace.log(`enter ${name} ${d}`);

src/main/ts/di/Container.ts +9 -2

             import { ActivationContext } from "./ActivationContext";
             import { ValueDescriptor } from "./ValueDescriptor";
             import { ActivationError } from "./ActivationError";
-            import { ServiceMap, Descriptor, PartialServiceMap, ContainerProvided, ServiceLocator, ContainerServiceMap, ContainerKeys, TypeOfService, ILifetimeManager } from "./interfaces";
+            import { ServiceMap, Descriptor, PartialServiceMap, ServiceLocator, ContainerServiceMap, ContainerKeys, TypeOfService } from "./interfaces";
             import { TraceSource } from "../log/TraceSource";
             import { Configuration, RegistrationMap } from "./Configuration";
             import { Cancellation } from "../Cancellation";
             import { isDescriptor } from "./traits";
             import { LifetimeManager } from "./LifetimeManager";
             import { each } from "../safe";
+            import { FluentRegistrations } from "./fluent/interfaces";
+            import { FluentConfiguration } from "./fluent/FluentConfiguration";
             const trace = TraceSource.get("@implab/core/di/ActivationContext");
             export class Container<S extends object = any> implements ServiceLocator<S>, IDestroyable {
                 readonly _services: ContainerServiceMap<S>;
-                readonly _lifetimeManager: ILifetimeManager;
+                readonly _lifetimeManager: LifetimeManager;
                 readonly _cleanup: (() => void)[];
                     }
                 }
+                async fluent<K extends keyof S>(config: FluentRegistrations<K, S>, ct = Cancellation.none): Promise<this> {
+                    await new FluentConfiguration<S>().register(config).apply(this, ct);
+                    return this;
+                }
                 createChildContainer<S2 extends object = S>(): Container<S & S2> {
                     return new Container<S & S2>(this as any);
                 }

src/main/ts/di/LifetimeManager.ts +33 -11

             import { IDestroyable, MapOf } from "../interfaces";
-            import { argumentNotNull, isDestroyable } from "../safe";
+            import { argumentNotNull, isDestroyable, primitive, isNull, argumentNotEmptyString } from "../safe";
-            import { ILifetimeManager, ILifetime } from "./interfaces";
+            import { ILifetime } from "./interfaces";
             import { ActivationContext } from "./ActivationContext";
             import { Container } from "./Container";
                 }
             }
-            const emptyLifetime: ILifetime = {
+            const emptyLifetime: ILifetime = Object.freeze({
                 has() {
                     return false;
                 },
                     // does nothing
                 }
-            };
+            });
-            const unknownLifetime: ILifetime = {
+            const unknownLifetime: ILifetime = Object.freeze({
                 has() {
-                    throw new Error("The lifetime is unknown");
+                    return false;
                 },
                 initialize() {
                     throw new Error("Can't call initialize on the unknown lifetime object");
                 store() {
                     throw new Error("Can't store a value in the unknown lifetime object");
                 }
+            });
             let nextId = 0;
-            export class LifetimeManager implements IDestroyable, ILifetimeManager {
+            const singletons: { [k in keyof any]: any; } = {};
+            export class LifetimeManager implements IDestroyable {
                 private _cleanup: (() => void)[] = [];
                 private _cache: MapOf<any> = {};
                 private _destroyed = false;
                             if (_lifetime !== unknownLifetime)
                                 throw new Error("Cyclic reference activation detected");
-                            _lifetime = context.getContainer().getLifetimeManager().create(context);
+                            _lifetime = context.getContainer().getLifetimeManager().create();
                         },
                         get() {
                             return _lifetime.get();
                 }
                 static singletonLifetime(typeId: string): ILifetime {
-                    return emptyLifetime;
+                    argumentNotEmptyString(typeId, "typeId");
+                    let pending = false;
+                    return {
+                        has() {
+                            return typeId in singletons;
+                        },
+                        get() {
+                            if (!this.has())
+                                throw new Error(`The instance ${typeId} doesn't exists`);
+                            return singletons[typeId];
+                        },
+                        initialize() {
+                            if (pending)
+                                throw new Error("Cyclic reference detected");
+                            pending = true;
+                        },
+                        store(item: any) {
+                            singletons[typeId] = item;
+                            pending = false;
+                        }
+                    };
                 }
                 static containerLifetime(container: Container<any>) {
                         initialize(context: ActivationContext<any>) {
                             if (_lifetime !== unknownLifetime)
                                 throw new Error("Cyclic reference detected");
-                            _lifetime = container.getLifetimeManager().create(context);
+                            _lifetime = container.getLifetimeManager().create();
                         },
                         get() {
                             return _lifetime.get();

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

             import { ActivationContext } from "./ActivationContext";
-            import { Descriptor, ServiceMap, PartialServiceMap, ILifetimeManager, ILifetime } from "./interfaces";
+            import { Descriptor, ServiceMap, PartialServiceMap, ILifetime } from "./interfaces";
             import { isPrimitive, keys, isNull } from "../safe";
             import { TraceSource } from "../log/TraceSource";
             import { isDescriptor } from "./traits";

src/main/ts/di/fluent/DescriptorBuilder.ts +122 -29

@@ -1,46 +1,94
1	import { Resolver, ~~LazyDependencyOptions~~, ~~DependencyOptions~~ } from "./interfaces";	1	import { Resolver, RegistrationBuilder } from "./interfaces";
2	import { Container } from "../Container";	2	import { Container } from "../Container";
3	import { Descriptor, ILifetime, ~~ContainerKeys~~ } from "../interfaces";	3	import { Descriptor, ILifetime, ActivationType, PartialServiceMap } from "../interfaces";
4	import { ActivationContext } from "../ActivationContext";	4	import { DescriptorImpl } from "./DescriptorImpl";
		5	import { LifetimeManager } from "../LifetimeManager";
		6	import { isString, each, isPrimitive, isPromise, oid } from "../../safe";
		7
		8	export class DescriptorBuilder<S extends object, T> {
		9	private readonly _container: Container<S>;
		10	private readonly _cb: (d: Descriptor<S, T>) => void;
		11
		12	private readonly _eb: (err: any) => void;
5		13
6	export class DescriptorBuilder<T, S extends object> {	14	private _lifetime = LifetimeManager.empty();
7	readonly _container: Container<S>;	15
8	readonly _cb: (d: Descriptor<S, T>) => void;	16	private _overrides?: PartialServiceMap<S>;
		17
		18	private _cleanup?: (item: T) => void;
9		19
10	constructor(container: Container<S>, cb: (d: Descriptor<S, T>) => void) {	20	private _factory?: (resolve: Resolver<S>) => T;
		21
		22	private _pending = 1;
		23
		24	private _failed = false;
		25
		26	constructor(container: Container<S>, cb: (d: Descriptor<S, T>) => void, eb: (err: any) => void) {
11	this._container = container;	27	this._container = container;
12	this._cb = cb;	28	this._cb = cb;
		29	this._eb = eb;
		30	}
		31
		32	build<T2>(): DescriptorBuilder<S, T2> {
		33	this._defer();
		34	return new DescriptorBuilder<S, T2>(this._container, () => this._complete(), err => this._fail(err));
13	}	35	}
14		36
15	factory(f: (resolve: Resolver<S>, activate: (lifetime: ILifetime, factory: () => any, cleanup?: (item: any) => void) => any) => T): void {	37	override<K extends keyof S>(name: K, builder: RegistrationBuilder<S, S[K]>): this;
16	this._cb({	38	override<K extends keyof S>(services: { [name in K]: RegistrationBuilder<S, S[K]> }): this;
17	activate(context: ActivationContext<S>) {	39	override<K extends keyof S>(nameOrServices: K \| { [name in K]: RegistrationBuilder<S, S[K]> }, builder?: RegistrationBuilder<S, S[K]>): this {
18	const resolve = (name: ContainerKeys<S>, opts?: DependencyOptions \| LazyDependencyOptions) => {	40	const overrides: PartialServiceMap<S> = this._overrides ?
19	if (opts && "lazy" in opts && opts.lazy) {	41	this._overrides :
20	const c2 = context.clone();	42	(this._overrides = {});
21	return () => {	43
22	return opts.optional ? c2.resolve(name, opts.default) : c2.resolve(name);	44	const guard = (v: void \| Promise<void>) => {
23	};	45	if (isPromise(v))
24	} else {	46	v.catch(err => this._fail(err));
25	return opts && opts.optional ? context.resolve(name, opts.default) : context.resolve(name);
26	}
27	};	47	};
28		48
29	const activate = (lifetime: ILifetime, factory: () => any, cleanup?: (item: any) => void) => {	49	if (isPrimitive(nameOrServices)) {
30	if (~~lifetime~~.~~has~~()) {	50	if (builder) {
31	return lifetime.get();	51	this._defer();
		52	const d = new DescriptorBuilder<S, S[K]>(
		53	this._container,
		54	result => {
		55	overrides[nameOrServices] = result;
		56	this._complete();
		57	},
		58	err => this._fail(err)
		59	);
		60
		61	try {
		62	guard(builder(d));
		63	} catch (err) {
		64	this._fail(err);
		65	}
		66	}
32	} else {	67	} else {
33	lifetime.initialize(context);	68	each(nameOrServices, (v, k) => this.override(k, v));
34	const instance = factory();	69	}
35	lifetime.store(instance, cleanup);	70	return this;
36	return instance;
37	}	71	}
38		72
39	};	73	lifetime(lifetime: "singleton", typeId: string): this;
		74	lifetime(lifetime: ILifetime \| Exclude<ActivationType, "singleton">): this;
		75	lifetime(lifetime: ILifetime \| ActivationType, typeId?: string): this {
		76	if (isString(lifetime)) {
		77	this._lifetime = this._resolveLifetime(lifetime, typeId);
		78	} else {
		79	this._lifetime = lifetime;
		80	}
		81	return this;
		82	}
40		83
41	return f(resolve, activate);	84	cleanup(cb: (item: T) => void): this {
		85	this._cleanup = cb;
		86	return this;
42	}	87	}
43	});	88
		89	factory(f: (resolve: Resolver<S>) => T): void {
		90	this._factory = f;
		91	this._complete();
44	}	92	}
45		93
46	value(v: T): void {	94	value(v: T): void {
@@ -51,4 +99,49 export class DescriptorBuilder<T, S exte
51	});	99	});
52	}	100	}
53		101
		102	_resolveLifetime(activation: ActivationType, typeId?: string \| object) {
		103	switch (activation) {
		104	case "container":
		105	return LifetimeManager.containerLifetime(this._container);
		106	case "hierarchy":
		107	return LifetimeManager.hierarchyLifetime();
		108	case "context":
		109	return LifetimeManager.contextLifetime();
		110	case "singleton":
		111	if (!typeId)
		112	throw Error("The singleton activation requires a typeId");
		113
		114	const _oid = isString(typeId) ? typeId : oid(typeId);
		115
		116	return LifetimeManager.singletonLifetime(_oid);
		117	default:
		118	return LifetimeManager.empty();
54	}	119	}
		120	}
		121
		122	_defer() {
		123	this._pending++;
		124	}
		125
		126	_complete() {
		127	if (--this._pending === 0) {
		128	if (!this._factory)
		129	throw new Error("The factory must be specified");
		130
		131	this._cb(new DescriptorImpl<S, T>({
		132	lifetime: this._lifetime,
		133	factory: this._factory,
		134	overrides: this._overrides,
		135	cleanup: this._cleanup
		136	}));
		137	}
		138	}
		139
		140	_fail(err: any) {
		141	if (!this._failed) {
		142	this._failed = true;
		143	this._eb.call(undefined, err);
		144	}
		145	}
		146
		147	}

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

             import { primitive } from "../../safe";
-            import { AnnotationBuilder } from "../Annotations";
+            import { TypeOfService, ContainerKeys, ActivationType, ILifetime } from "../interfaces";
-            import { ILifetime, TypeOfService, ContainerKeys } from "../interfaces";
+            import { ICancellation } from "../../interfaces";
             export interface DependencyOptions {
                 optional?: boolean;
             export type WalkDependencies<D, S> = D extends primitive ? D :
                 { [K in keyof D]: ExtractDependency<D[K], S> };
-            export type ServiceModule<T, S extends object, M extends keyof any = "service"> = {
-                [m in M]: AnnotationBuilder<T, S>;
-            };
             export type InferReferenceType<S extends object, K extends ContainerKeys<S>, O> = O extends { default: infer X } ? (TypeOfService<S, K> | X) :
                 O extends { optional: true } ? (TypeOfService<S, K> | undefined) :
                 TypeOfService<S, K>;
                 <K extends ContainerKeys<S>, O extends DependencyOptions>(this: void, name: K, opts?: O): InferReferenceType<S, K, O>;
             }
-            export interface DescriptorBuilder<T, S extends object> {
+            export interface DescriptorBuilder<S extends object, T> {
-                service(service: AnnotationBuilder<T, S> | ServiceModule<T, S>): void;
+                factory(f: (resolve: Resolver<S>) => T): void;
+                build<T2>(): DescriptorBuilder<S, T2>;
-                factory(f: (resolve: Resolver<S>, activate: <T2>(lifetime: ILifetime, factory: () => T2, cleanup?: (item: T2) => void) => T2) => T): void;
+                override<K extends keyof S>(name: K, builder: RegistrationBuilder<S, S[K]>): this;
+                override<K extends keyof S>(services: { [name in K]: RegistrationBuilder<S, S[K]> }): this;
+                lifetime(lifetime: "singleton", typeId: any): this;
+                lifetime(lifetime: ILifetime | Exclude<ActivationType, "singleton">): this;
+                cleanup(cb: (item: T) => void): this;
                 value(v: T): void;
             }
-            export interface Configuration<S extends object, Y extends keyof S = keyof S> {
+            export type RegistrationBuilder<S extends object, T> = (d: DescriptorBuilder<S, T>, ct?: ICancellation) => void | Promise<void>;
-                register<K extends Y>(name: K, builder: (d: DescriptorBuilder<S[K], S>) => void): Configuration<S, Exclude<Y, K>>;
+            export type FluentRegistrations<K extends keyof S, S extends object> = { [k in K]: RegistrationBuilder<S, S[k]> };

src/main/ts/di/interfaces.ts 0 -4

             export type ActivationType = "singleton" | "container" | "hierarchy" | "context" | "call";
-            export interface ILifetimeManager {
-                create(context: ActivationContext<any>): ILifetime;
             /**
              * Интерфейс для управления жизнью экземпляра объекта. Каждая регистрация имеет
              * свой собственный объект `ILifetime`, который создается при первой активации

src/main/ts/di/traits.ts +3 -4

             import { isPrimitive } from "../safe";
             import { Descriptor } from "./interfaces";
-            import { Configuration } from "./fluent/Configuration";
+            import { FluentConfiguration } from "./fluent/FluentConfiguration";
             export function isDescriptor(x: any): x is Descriptor {
                 return (!isPrimitive(x)) &&
                     (x.activate instanceof Function);
             }
-            export function configure<S extends object>() {
+            export function fluent<S extends object>() {
-                return new Configuration<S>();
+                return new FluentConfiguration<S>();
             }

src/main/ts/safe.ts +3 -1

-            import { ICancellable, Constructor, IDestroyable } from "./interfaces";
+            import { ICancellable, Constructor, IDestroyable, PromiseOrValue } from "./interfaces";
             import { Cancellation } from "./Cancellation";
             let _nextOid = 0;
                 Symbol("__implab__oid__") :
                 "__implab__oid__";
+            export function oid(instance: null | undefined): undefined;
+            export function oid(instance: NonNullable<any>): string;
             export function oid(instance: any): string | undefined {
                 if (isNull(instance))
                     return undefined;

src/test/ts/mock/config.ts +15 -12

@@ -1,16 +1,19
1	import { Services } from "./services";	1	import { Services } from "./services";
2	import { ~~configure~~ } from "../di/traits";	2	import { fluent } from "../di/traits";
3	import { LifetimeManager } from "../di/LifetimeManager";	3
		4	export default fluent<Services>().register({
		5	host: it => it.value("example.com"),
4		6
5	export const config = configure<Services>()	7	bar2: it => Promise.all([import("./Foo"), import("./Bar")])
6	.register("host", s => s.value("example.com"))	8	.then(([{ Foo }, { Bar }]) => it
7	.register("bar2", bar2 => Promise.all([import("./Foo"), import("./Bar")])	9	.lifetime("container")
8	.then(([{ Foo }, { Bar }]) => {	10	.override({
9	const lifetime = LifetimeManager.hierarchyLifetime();	11	host: it2 => it2.value("simple.org"),
10		12	foo: it2 => it2.value(new Foo())
11	bar2.factory((resolve, activate) => {	13	})
		14	.factory(resolve => {
12	const bar = new Bar({	15	const bar = new Bar({
13	foo: ~~activate~~(~~lifetime~~, () => new Foo()),	16	foo: new Foo(),
14	nested: {	17	nested: {
15	lazy: resolve("foo", { lazy: true })	18	lazy: resolve("foo", { lazy: true })
16	},	19	},
@@ -18,6 +21,6 export const config = configure<Services
18	}, "some text");	21	}, "some text");
19	bar.setName(resolve("host"));	22	bar.setName(resolve("host"));
20	return bar;	23	return bar;
		24	})
		25	)
21	});	26	});
22	})
23	);

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

             import { Foo } from "../mock/Foo";
             import { Bar } from "../mock/Bar";
             import { isNull } from "../safe";
-            import { Box } from "ts/mock/Box";
             test("Container register/resolve tests", async t => {
                 const container = new Container<{

src/test/tsconfig.json 0 -2

             {
                 "extends": "../tsconfig",
                 "compilerOptions": {
-                    //"rootDir": "ts",
-                    "baseUrl": ".",
                     "rootDirs": [
                         "ts",
                         "../main/ts"

src/testAmd/js/tests/plan.js +2 -1

                 "./ObservableTests",
                 "./ContainerTests",
                 "./SafeTests",
-                "./TextTests"
+                "./TextTests",
+                "./FluentContainerTests"
             ]);

src/main/ts/di/Annotations.ts removed 0 -25

NO CONTENT: file was removed

src/main/ts/di/fluent/Configuration.ts removed 0 -59

NO CONTENT: file was removed

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