implab/implabjs-core Commit - r122:118478dfa903

Added LazyReferenceDescriptor, removed lazy behaviour from ReferenceDescriptor.

cin -

r122:118478dfa903 ioc ts support

parent child

Context file:

r122:118478dfa903

Collapse all files

src/main/ts/di/LazyReferenceDescriptor.ts created 644 +84 0

@@ -0,0 +1,84
	1	import { argumentNotEmptyString, each } from "../safe";
	2	import { ActivationContext } from "./ActivationContext";
	3	import { Descriptor, PartialServiceMap, ContainerResolve, ContainerKeys } from "./interfaces";
	4	import { ActivationError } from "./ActivationError";
	5
	6	export interface ReferenceDescriptorParams<S extends object, K extends ContainerKeys<S>> {
	7	name: K;
	8	optional?: boolean;
	9	default?: ContainerResolve<S, K>;
	10	services?: PartialServiceMap<S>;
	11	}
	12
	13	export class LazyReferenceDescriptor<S extends object = any, K extends ContainerKeys<S> = ContainerKeys<S>>
	14	implements Descriptor<S, ((args?: PartialServiceMap<S>) => ContainerResolve<S, K>)> {
	15
	16	_name: K;
	17
	18	_optional = false;
	19
	20	_default: ContainerResolve<S, K> \| undefined;
	21
	22	_services: PartialServiceMap<S>;
	23
	24	constructor(opts: ReferenceDescriptorParams<S, K>) {
	25	argumentNotEmptyString(opts && opts.name, "opts.name");
	26	this._name = opts.name;
	27	this._optional = !!opts.optional;
	28	this._default = opts.default;
	29
	30	this._services = (opts.services \|\| {}) as PartialServiceMap<S>;
	31	}
	32
	33	activate(context: ActivationContext<S>) {
	34	// добавляем сервисы
	35	if (this._services) {
	36	each(this._services, (v, k) => context.register(k, v));
	37	}
	38
	39	const saved = context.clone();
	40
	41	return (cfg?: PartialServiceMap<S>) => {
	42	// защищаем контекст на случай исключения в процессе
	43	// активации
	44	const ct = saved.clone();
	45	try {
	46	if (cfg) {
	47	each(cfg, (v, k) => ct.register(k, v));
	48	}
	49
	50	return this._optional ? ct.resolve(this._name, this._default) : ct
	51	.resolve(this._name);
	52	} catch (error) {
	53	throw new ActivationError(this._name.toString(), ct.getStack(), error);
	54	}
	55	};
	56
	57	}
	58
	59	toString() {
	60	const opts = [];
	61	if (this._optional)
	62	opts.push("optional");
	63
	64	opts.push("lazy");
	65
	66	const parts = [
	67	"@ref "
	68	];
	69	if (opts.length) {
	70	parts.push("{");
	71	parts.push(opts.join());
	72	parts.push("} ");
	73	}
	74
	75	parts.push(this._name.toString());
	76
	77	if (this._default !== undefined && this._default !== null) {
	78	parts.push(" = ");
	79	parts.push(String(this._default));
	80	}
	81
	82	return parts.join("");
	83	}
	84	}

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

                 [m in M]: Builder<T, S>;
             };
+            type PromiseOrValue<T> = PromiseLike<T> | T;
             export interface Config<S extends object, Y extends keyof S = keyof S> {
                 register<K extends Y>(name: K, builder: Builder<S[K], S>): Config<S, Exclude<Y, K>>;
                 register<K extends Y>(name: K, m: Promise<ServiceModule<S[K], S>>): Config<S, Exclude<Y, K>>;

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

             import { makeResolver } from "./ResolverHelper";
             import { ICancellation } from "../interfaces";
             import { isDescriptor } from "./traits";
+            import { LazyReferenceDescriptor } from "./LazyReferenceDescriptor";
             export interface RegistrationScope<S extends object> {
                 async _visitDependencyRegistration<K extends keyof S>(data: DependencyRegistration<S, K>, name: string) {
                     argumentNotEmptyString(data && data.$dependency, "data.$dependency");
                     this._enter(name);
-                    const d = new ReferenceDescriptor<S, K>({
+                    const options = {
                         name: data.$dependency,
-                        lazy: data.lazy,
                         optional: data.optional,
                         default: data.default,
                         services: data.services && await this._visitRegistrations(data.services, "services")
-                    });
+                    };
+                    const d = data.lazy ? new LazyReferenceDescriptor<S, K>(options) : new ReferenceDescriptor<S, K>(options);
                     this._leave();
                     return d;
                 }

src/main/ts/di/ReferenceDescriptor.ts +3 -30

             import { argumentNotEmptyString, each } from "../safe";
             import { ActivationContext } from "./ActivationContext";
             import { Descriptor, PartialServiceMap, ContainerResolve, ContainerKeys } from "./interfaces";
-            import { ActivationError } from "./ActivationError";
             export interface ReferenceDescriptorParams<S extends object, K extends ContainerKeys<S>> {
                 name: K;
-                lazy?: boolean;
                 optional?: boolean;
                 default?: ContainerResolve<S, K>;
                 services?: PartialServiceMap<S>;
             }
             export class ReferenceDescriptor<S extends object = any, K extends ContainerKeys<S> = ContainerKeys<S>>
-                implements Descriptor<S, ContainerResolve<S, K> | ((args?: PartialServiceMap<S>) => ContainerResolve<S, K>)> {
+                implements Descriptor<S, ContainerResolve<S, K>> {
                 _name: K;
-                _lazy = false;
                 _optional = false;
                 _default: ContainerResolve<S, K> | undefined;
                 constructor(opts: ReferenceDescriptorParams<S, K>) {
                     argumentNotEmptyString(opts && opts.name, "opts.name");
                     this._name = opts.name;
-                    this._lazy = !!opts.lazy;
                     this._optional = !!opts.optional;
                     this._default = opts.default;
                         each(this._services, (v, k) => context.register(k, v));
                     }
-                    if (this._lazy) {
+                    const res = this._optional ?
-                        const saved = context.clone();
-                        return (cfg?: PartialServiceMap<S>) => {
-                            // защищаем контекст на случай исключения в процессе
-                            // активации
-                            const ct = saved.clone();
-                            try {
-                                if (cfg) {
-                                    each(cfg, (v, k) => ct.register(k, v));
-                                return this._optional ? ct.resolve(this._name, this._default) : ct
-                                    .resolve(this._name);
-                            } catch (error) {
-                                throw new ActivationError(this._name.toString(), ct.getStack(), error);
-                        };
-                    } else {
-                        const v = this._optional ?
                         context.resolve(this._name, this._default) :
                         context.resolve(this._name);
-                        return v;
+                    return res;
                 }
                 toString() {
                     const opts = [];
                     if (this._optional)
                         opts.push("optional");
-                    if (this._lazy)
-                        opts.push("lazy");
                     const parts = [
                         "@ref "

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