implab/implabjs-core Commit - r134:511bcc634d65

working on fluent configuration, di annotations removed

cin -

r134:511bcc634d65 ioc ts support

parent child

Context file:

r134:511bcc634d65

Collapse all files

src/amd/js/data/StoreAdapter.js 0 -1

                             });
                             mapped.total = total;
                             var results = new QueryResults(mapped);
-                            console.log(results);
                             return results;
                         });
                     },

src/main/ts/components/AsyncComponent.ts +5 -4

             import { IAsyncComponent, ICancellation, ICancellable, IDestroyable } from "../interfaces";
             import { destroy } from "../safe";
+            const noop = () => void (0);
             export class AsyncComponent implements IAsyncComponent, ICancellable {
-                _cancel: ((e: any) => void) | undefined;
+                _cancel: ((e: any) => void) = noop;
                 _completion: Promise<void> = Promise.resolve();
                             // after the operation is complete we need to cleanup the
                             // resources
                             destroy(h);
-                            this._cancel = undefined;
+                            this._cancel = noop;
                         }
                     };
                 }
                 cancel(reason: any) {
-                    if (this._cancel)
+                    this._cancel(reason);
-                        this._cancel(reason);
                 }
             }

src/main/ts/di/ActivationContext.ts +19 -12

@@ -1,6 +1,6
1	import { TraceSource } from "../log/TraceSource";	1	import { TraceSource } from "../log/TraceSource";
2	import { argumentNotEmptyString } from "../safe";	2	import { argumentNotEmptyString } from "../safe";
3	import { Descriptor, ContainerServiceMap, ContainerKeys, TypeOfService } from "./interfaces";	3	import { Descriptor, ContainerServiceMap, ContainerKeys, TypeOfService, ILifetime } from "./interfaces";
4	import { Container } from "./Container";	4	import { Container } from "./Container";
5	import { MapOf } from "../interfaces";	5	import { MapOf } from "../interfaces";
6		6
@@ -13,6 +13,8 export interface ActivationContextInfo {
13		13
14	}	14	}
15		15
		16	let nextId = 1;
		17
16	export class ActivationContext<S extends object> {	18	export class ActivationContext<S extends object> {
17	_cache: MapOf<any>;	19	_cache: MapOf<any>;
18		20
@@ -73,18 +75,23 export class ActivationContext<S extends
73	this._services[name] = service as any;	75	this._services[name] = service as any;
74	}	76	}
75		77
76	has(id: string) {	78	createLifetime(): ILifetime {
77	return id in this._cache;	79	const id = nextId++;
		80	const me = this;
		81	return {
		82	initialize() {
		83	},
		84	has() {
		85	return id in me._cache;
		86	},
		87	get() {
		88	return me._cache[id];
		89	},
		90	store(item: any) {
		91	me._cache[id] = item;
		92	}
		93	};
78	}	94	}
79
80	get<T>(id: string) {
81	return this._cache[id];
82	}
83
84	store(id: string, value: any) {
85	return (this._cache[id] = value);
86	}
87
88	activate<T>(d: Descriptor<S, T>, name: string) {	95	activate<T>(d: Descriptor<S, T>, name: string) {
89	if (trace.isLogEnabled())	96	if (trace.isLogEnabled())
90	trace.log(`enter ${name} ${d}`);	97	trace.log(`enter ${name} ${d}`);

src/main/ts/di/Configuration.ts +16 -12

                 ActivationType,
                 ContainerKeys,
                 TypeOfService,
-                ILifetimeManager
+                ILifetime
             } from "./interfaces";
             import { argumentNotEmptyString, isPrimitive, isPromise, delegate, argumentOfType, argumentNotNull, get, primitive } from "../safe";
                     trace.debug("<{0}", name);
                 }
-                async _visit(data: any, name: string): Promise<any> {
+                _visit(data: any, name: string): Promise<any> {
-                    if (isPrimitive(data) || isDescriptor(data))
+                    if (isPrimitive(data))
-                        return data;
+                        return Promise.resolve(new ValueDescriptor(data));
+                    if (isDescriptor(data))
+                        return Promise.resolve(data);
                     if (isDependencyRegistration<S>(data)) {
                         return this._visitDependencyRegistration(data, name);
                         opts.type = data.$type;
                     } else {
                         const [moduleName, typeName] = data.$type.split(":", 2);
-                        const t = opts.type = this._resolveType(moduleName, typeName);
+                        opts.type = this._resolveType(moduleName, typeName).then(t => {
-                        if (!(t instanceof Function))
+                            if (!(t instanceof Function))
-                            throw Error("$type (" + data.$type + ") is not a constructable");
+                                throw Error("$type (" + data.$type + ") is not a constructable");
+                            return t;
+                        });
                     }
                     const d = new TypeServiceDescriptor<S, any, any[]>(
                     return d;
                 }
-                _getLifetimeManager(activation: ActivationType, typeId: string | undefined): ILifetimeManager {
+                _getLifetimeManager(activation: ActivationType, typeId: string | undefined): ILifetime {
                     switch (activation) {
                         case "container":
-                            return this._container.getLifetimeManager();
+                            return LifetimeManager.containerLifetime(this._container);
                         case "hierarchy":
-                            return LifetimeManager.hierarchyLifetime;
+                            return LifetimeManager.hierarchyLifetime();
                         case "context":
-                            return LifetimeManager.contextLifetime;
+                            return LifetimeManager.contextLifetime();
                         case "singleton":
                             if (typeId === undefined)
                                 throw Error("The singleton activation requires a typeId");
                             return LifetimeManager.singletonLifetime(typeId);
                         default:
-                            return LifetimeManager.empty;
+                            return LifetimeManager.empty();
                     }
                 }
             }

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

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

src/main/ts/di/LifetimeManager.ts +80 -36

@@ -2,6 +2,7 import { IDestroyable, MapOf } from "../
2	import { argumentNotNull, isDestroyable } from "../safe";	2	import { argumentNotNull, isDestroyable } from "../safe";
3	import { ILifetimeManager, ILifetime } from "./interfaces";	3	import { ILifetimeManager, ILifetime } from "./interfaces";
4	import { ActivationContext } from "./ActivationContext";	4	import { ActivationContext } from "./ActivationContext";
		5	import { Container } from "./Container";
5		6
6	function safeCall(item: () => void) {	7	function safeCall(item: () => void) {
7	try {	8	try {
@@ -16,7 +17,7 const emptyLifetime: ILifetime = {
16	return false;	17	return false;
17	},	18	},
18		19
19	enter() {	20	initialize() {
20		21
21	},	22	},
22		23
@@ -30,6 +31,21 const emptyLifetime: ILifetime = {
30		31
31	};	32	};
32		33
		34	const unknownLifetime: ILifetime = {
		35	has() {
		36	throw new Error("The lifetime is unknown");
		37	},
		38	initialize() {
		39	throw new Error("Can't call initialize on the unknown lifetime object");
		40	},
		41	get() {
		42	throw new Error("The lifetime object isn't initialized");
		43	},
		44	store() {
		45	throw new Error("Can't store a value in the unknown lifetime object");
		46	}
		47	}
		48
33	let nextId = 0;	49	let nextId = 0;
34		50
35	export class LifetimeManager implements IDestroyable, ILifetimeManager {	51	export class LifetimeManager implements IDestroyable, ILifetimeManager {
@@ -39,7 +55,7 export class LifetimeManager implements
39		55
40	private _pending: MapOf<boolean> = {};	56	private _pending: MapOf<boolean> = {};
41		57
42	~~initializ~~e(): ILifetime {	58	create(): ILifetime {
43	const self = this;	59	const self = this;
44	const id = ++nextId;	60	const id = ++nextId;
45	return {	61	return {
@@ -54,7 +70,7 export class LifetimeManager implements
54	return t;	70	return t;
55	},	71	},
56		72
57	~~enter~~() {	73	initialize() {
58	if (self._pending[id])	74	if (self._pending[id])
59	throw Error(`Cyclic reference detected: the item with the key ${id} is already activating.`);	75	throw Error(`Cyclic reference detected: the item with the key ${id} is already activating.`);
60	self._pending[id] = true;	76	self._pending[id] = true;
@@ -89,43 +105,71 export class LifetimeManager implements
89	}	105	}
90	}	106	}
91		107
92	static ~~readonly~~ ~~empty~~: ILifetime~~Manager~~ = {	108	static empty(): ILifetime {
93	initialize(): ILifetime {	109	return emptyLifetime;
94	return emptyLifetime;	110	}
95	}	111
96	};	112	static hierarchyLifetime(): ILifetime {
		113	let _lifetime = unknownLifetime;
		114	return {
		115	initialize(context: ActivationContext<any>) {
		116	if (_lifetime !== unknownLifetime)
		117	throw new Error("Cyclic reference activation detected");
97		118
98	static readonly hierarchyLifetime: ILifetimeManager = {	119	_lifetime = context.getContainer().getLifetimeManager().create(context);
99	initialize(context: ActivationContext<any>): ILifetime {	120	},
100	return context.getContainer().getLifetimeManager().initialize(context);	121	get() {
101	}	122	return _lifetime.get();
102	};	123	},
		124	has() {
		125	return _lifetime.has();
		126	},
		127	store(item: any, cleanup?: (item: any) => void) {
		128	return _lifetime.store(item, cleanup);
		129	}
		130	};
		131	}
103		132
104	static ~~readonly~~ ~~contextLifetime~~: ILifetime~~Manager~~ = {	133	static contextLifetime(): ILifetime {
105	initialize(context: ActivationContext<any>): ILifetime {	134	let _lifetime = unknownLifetime;
106	const id = String(++nextId);	135	return {
107	return {	136	initialize(context: ActivationContext<any>) {
108	enter() {	137	if (_lifetime !== unknownLifetime)
109	if (context.visit(id))	138	throw new Error("Cyclic reference detected");
110	throw new Error("Cyclic reference detected");	139	_lifetime = context.createLifetime();
111	},	140	},
112	get() {	141	get() {
113	return ~~context~~.get(id);	142	return _lifetime.get();
114	},	143	},
115	has() {	144	has() {
116	return ~~context~~.has(id);	145	return _lifetime.has();
117	},	146	},
118	store(item: any) {	147	store(item: any) {
119	~~context~~.store(id, item);	148	_lifetime.store(item);
120	}	149	}
121	};	150	};
122	}	151	}
123	};
124		152
125	static singletonLifetime(typeId: string): ILifetime~~Manager~~ {	153	static singletonLifetime(typeId: string): ILifetime {
		154	return emptyLifetime;
		155	}
		156
		157	static containerLifetime(container: Container<any>) {
		158	let _lifetime = unknownLifetime;
126	return {	159	return {
127	initialize() {	160	initialize(context: ActivationContext<any>) {
128	~~return~~ ~~emptyLifetime~~;	161	if (_lifetime !== unknownLifetime)
		162	throw new Error("Cyclic reference detected");
		163	_lifetime = container.getLifetimeManager().create(context);
		164	},
		165	get() {
		166	return _lifetime.get();
		167	},
		168	has() {
		169	return _lifetime.has();
		170	},
		171	store(item: any) {
		172	_lifetime.store(item);
129	}	173	}
130	};	174	};
131	}	175	}

src/main/ts/di/ReferenceDescriptor.ts +21 -1

             import { Descriptor, PartialServiceMap, TypeOfService, ContainerKeys } from "./interfaces";
             export interface ReferenceDescriptorParams<S extends object, K extends ContainerKeys<S>> {
+                /**
+                 * The name of the descriptor
+                 */
                 name: K;
+                /**
+                 * The flag that indicates that the referenced service isn't required to exist.
+                 * If the reference is optional and the referenced service doesn't exist,
+                 * the undefined or a default value will be returned.
+                 */
                 optional?: boolean;
+                /**
+                 * a default value for the reference when the referenced service doesn't exist.
+                 */
                 default?: TypeOfService<S, K>;
+                /**
+                 * The service overrides
+                 */
                 services?: PartialServiceMap<S>;
             }
                     this._services = (opts.services || {}) as PartialServiceMap<S>;
                 }
-                activate(context: ActivationContext<S>) {
+                /** This method activates the referenced service if one exists
+                 * @param context activation context which is used during current activation
+                 */
+                activate(context: ActivationContext<S>): any {
                     // добавляем сервисы
                     if (this._services) {
                         each(this._services, (v, k) => context.register(k, v));

src/main/ts/di/ServiceDescriptor.ts +5 -8

             };
             export interface ServiceDescriptorParams<S extends object, T, P extends any[]> {
-                lifetime?: ILifetimeManager;
+                lifetime?: ILifetime;
                 params?: P;
                 _cleanup: ((item: T) => void) | undefined;
-                _lifetimeManager = LifetimeManager.empty;
+                _lifetime = LifetimeManager.empty();
                 _objectLifetime: ILifetime | undefined;
                 constructor(opts: ServiceDescriptorParams<S, T, P>) {
                     if (opts.lifetime)
-                        this._lifetimeManager = opts.lifetime;
+                        this._lifetime = opts.lifetime;
                     if (!isNull(opts.params))
                         this._params = opts.params;
                 }
                 activate(context: ActivationContext<S>) {
-                    if (!this._objectLifetime)
+                    const lifetime = this._lifetime;
-                        this._objectLifetime = this._lifetimeManager.initialize(context);
-                    const lifetime = this._objectLifetime;
                     if (lifetime.has()) {
                         return lifetime.get();
                     } else {
-                        lifetime.enter();
+                        lifetime.initialize(context);
                         const instance = this._create(context);
                         lifetime.store(instance, this._cleanup);
                         return instance;

src/main/ts/di/fluent/DescriptorBuilder.ts +2 -6

-            import { Resolver, ServiceModule, LazyDependencyOptions, DependencyOptions } from "./interfaces";
+            import { Resolver, LazyDependencyOptions, DependencyOptions } from "./interfaces";
-            import { AnnotationBuilder } from "../Annotations";
             import { Container } from "../Container";
             import { Descriptor, ILifetime, ContainerKeys } from "../interfaces";
             import { ActivationContext } from "../ActivationContext";
                     this._container = container;
                     this._cb = cb;
                 }
-                service(service: AnnotationBuilder<T, S> | ServiceModule<T, S>) {
                 factory(f: (resolve: Resolver<S>, activate: (lifetime: ILifetime, factory: () => any, cleanup?: (item: any) => void) => any) => T): void {
                     this._cb({
                                 if (lifetime.has()) {
                                     return lifetime.get();
                                 } else {
-                                    lifetime.enter();
+                                    lifetime.initialize(context);
                                     const instance = factory();
                                     lifetime.store(instance, cleanup);
                                     return instance;

src/main/ts/di/fluent/interfaces.ts +3 -3

                 [m in M]: AnnotationBuilder<T, S>;
             };
-            export type InferReferenceType<S extends object, K extends keyof ContainerKeys<S>, O> = O extends { default: infer X } ? (TypeOfService<S, K> | X) :
+            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>;
             export interface Resolver<S extends object> {
-                <K extends keyof ContainerKeys<S>, O extends LazyDependencyOptions>(this: void, name: K, opts: O): () => InferReferenceType<S, K, O>;
+                <K extends ContainerKeys<S>, O extends LazyDependencyOptions>(this: void, name: K, opts: O): () => InferReferenceType<S, K, O>;
-                <K extends keyof ContainerKeys<S>, O extends DependencyOptions>(this: void, name: K, opts?: O): InferReferenceType<S, K, O>;
+                <K extends ContainerKeys<S>, O extends DependencyOptions>(this: void, name: K, opts?: O): InferReferenceType<S, K, O>;
             }
             export interface DescriptorBuilder<T, S extends object> {

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

             export type ActivationType = "singleton" | "container" | "hierarchy" | "context" | "call";
             export interface ILifetimeManager {
-                initialize(context: ActivationContext<any>): ILifetime;
+                create(context: ActivationContext<any>): ILifetime;
             }
             /**
                 get(): any;
-                enter(): void;
+                initialize(context: ActivationContext<any>): void;
                 store(item: any, cleanup?: (item: any) => void): void;
             }

src/main/ts/di/traits.ts +2 -13

@@ -1,6 +1,5
1	import { isPrimitive } from "../safe";	1	import { isPrimitive } from "../safe";
2	import { Descriptor } from "./interfaces";	2	import { Descriptor } from "./interfaces";
3	import { AnnotationBuilder } from "./Annotations";
4	import { Configuration } from "./fluent/Configuration";	3	import { Configuration } from "./fluent/Configuration";
5		4
6	export function isDescriptor(x: any): x is Descriptor {	5	export function isDescriptor(x: any): x is Descriptor {
@@ -8,16 +7,6 export function isDescriptor(x: any): x
8	(x.activate instanceof Function);	7	(x.activate instanceof Function);
9	}	8	}
10		9
11	export function ~~decla~~re<S extends object>() {	10	export function configure<S extends object>() {
12	return {	11	return new Configuration<S>();
13	annotate<T>() {
14	return new AnnotationBuilder<T, S>();
15	},
16	configure(): Configuration<S> {
17	throw new Error();
18	},
19	dependency() {
20	throw new Error();
21	}
22	};
23	}	12	}

src/main/ts/safe.ts +7 -12

              * @param {Function} cb функция, вызываемая для каждого элемента
              * @param {Object} thisArg значение, которое будет передано в качестве
              *                <c>this</c> в <c>cb</c>.
-             * @returns Результат вызова функции <c>cb</c>, либо <c>undefined</c>
+             * @returns {void}
-             *          если достигнут конец массива.
              */
             export function each<T>(obj: T, cb: <X extends keyof T>(v: NonNullable<T[X]>, k: X) => void): void;
             export function each<T>(array: T[], cb: (v: T, i: number) => void): void;
             export function each(obj: any, cb: any, thisArg?: any) {
                 argumentNotNull(cb, "cb");
                 if (obj instanceof Array) {
+                    let v: any;
                     for (let i = 0; i < obj.length; i++) {
-                        const x = cb.call(thisArg, obj[i], i);
+                        v = obj[i];
-                        if (x !== undefined)
+                        if (v !== undefined)
-                            return x;
+                            cb.call(thisArg, v, i);
                     }
                 } else {
-                    const _keys = Object.keys(obj);
+                    Object.keys(obj).forEach(k => obj[k] !== undefined && cb.call(thisArg, obj[k], k));
-                    for (const k of _keys) {
-                        const x = cb.call(thisArg, obj[k], k);
-                        if (x !== undefined)
-                            return x;
                 }
             }
             }
             export function isDestroyable(d: any): d is IDestroyable {
-                if (d && "destroy" in d && typeof(destroy) === "function")
+                if (d && "destroy" in d && typeof (destroy) === "function")
                     return true;
                 return false;
             }

src/main/ts/text/StringFormat.ts +1 -1

-            import { isPrimitive, isNull, each, isKeyof, get } from "../safe";
+            import { isPrimitive, isNull, isKeyof, get } from "../safe";
             import { MapOf } from "../interfaces";
             type SubstFn = (name: string, format?: string) => string;

src/test/ts/mock/Bar.ts +13 -9

             import { Foo } from "./Foo";
-            import { annotate, dependency } from "./services";
-            export const service = annotate<Bar>();
+            /* export const service = annotate<Bar>();
             @service.wire({
                 foo: dependency("foo"),
                     lazy: dependency("foo", { lazy: true })
                 },
                 host: dependency("host")
-            }, "")
+            }, "") */
             export class Bar {
                 barName = "Twister";
                 _v: Foo | undefined;
-                constructor(_opts: {
+                constructor(
-                    foo?: Foo;
+                    _opts: {
-                    nested?: {
+                        foo?: Foo;
-                        lazy: () => Foo
+                        nested?: {
+                            lazy: () => Foo
+                        },
+                        host: string
                     },
-                    host: string
+                    s: string
-                }, s: string) {
+                ) {
                     if (_opts && _opts.foo)
                         this._v = _opts.foo;
+                    if (s)
+                        this.barName = s;
                 }
                 setName(name: string) {

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

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

src/test/ts/mock/config.ts +6 -3

-            import { configure } from "./services";
+            import { Services } from "./services";
+            import { configure } from "../di/traits";
+            import { LifetimeManager } from "../di/LifetimeManager";
-            export const config = configure()
+            export const config = configure<Services>()
                 .register("host", s => s.value("example.com"))
                 .register("bar2", bar2 => Promise.all([import("./Foo"), import("./Bar")])
                     .then(([{ Foo }, { Bar }]) => {
-                        const lifetime: any = undefined; // new HierarchyLifetime()
+                        const lifetime = LifetimeManager.hierarchyLifetime();
                         bar2.factory((resolve, activate) => {
                             const bar = new Bar({
                                 foo: activate(lifetime, () => new Foo()),

src/test/ts/mock/services.ts 0 -6

             import { Foo } from "./Foo";
             import { Bar } from "./Bar";
             import { Box } from "./Box";
-            import { declare } from "../di/traits";
             /**
              * Сервисы доступные внутри контейнера
                 host: string;
             }
-            /**
-             * Экспортируем вспомогательные функции для описания сервисов и кинфогурации
-             */
-            export const { dependency, annotate, configure } = declare<Services>();

src/test/ts/tests/ConfigurationBuilderTests.ts removed 0 -36

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