implab/implabjs-di Commit - r11:dd37d4287c45

WIP lifetime services, change target to ES2018

cin -

r11:dd37d4287c45 default

parent child

Context file:

r11:dd37d4287c45

Collapse all files

src/main/ts/ActivationContext.ts +13 -12

@@ -1,5 +1,6
		1	import { ActivationError } from "./ActivationError";
1	import { Descriptor, ILifetime, IActivationContext, DescriptorMap, ILifetimeManager } from "./interfaces";	2	import { Descriptor, ILifetime, IActivationContext, DescriptorMap, ILifetimeManager } from "./interfaces";
2	import { argumentNotNull } from "./traits";	3	import { argumentNotNull, prototype } from "./traits";
3		4
4	export interface ActivationContextInfo {	5	export interface ActivationContextInfo {
5	name: string;	6	name: string;
@@ -110,7 +111,14 export class ActivationContext<S> implem
110	// if (trace.isLogEnabled())	111	// if (trace.isLogEnabled())
111	// trace.log("enter {0} {1}", name, d);	112	// trace.log("enter {0} {1}", name, d);
112		113
113	const ctx = ~~this~~.~~enter~~(d, ~~name~~);	114	const ctx = new ActivationContext(
		115	this._containerLifetimeManager,
		116	d.hasOverrides ? prototype(this._services) : this._services,
		117	name,
		118	d,
		119	this._cache
		120	);
		121
114	const v = d.activate(ctx);	122	const v = d.activate(ctx);
115		123
116	// if (trace.isLogEnabled())	124	// if (trace.isLogEnabled())
@@ -130,15 +138,8 export class ActivationContext<S> implem
130	stack;	138	stack;
131	}	139	}
132		140
133	private enter(service: Descriptor<S, unknown>, name: string) {	141	fail(innerException: unknown): never {
134	return new ActivationContext(	142	throw new ActivationError(this._name, this.getStack(), innerException);
135	this._containerLifetimeManager,
136	service.hasOverrides ?
137	Object.create(this._services) as typeof this._services :
138	this._services,
139	name,
140	service,
141	this._cache
142	);
143	}	143	}
		144
144	}	145	}

src/main/ts/ContainerBuilder.ts +3 -3

             import { DescriptorBuilder } from "./DescriptorBuilder";
             import { Descriptor, IContainerBuilder, IDescriptorBuilder, DescriptorMap, ServiceLocator, ILifetime, IDestroyable } from "./interfaces";
             import { emptyLifetime, LifetimeManager } from "./LifetimeManager";
-            import { isDestroyable } from "./traits";
+            import { isDestroyable, prototype } from "./traits";
             /**
              * Container builder used to prepare service descriptors and create a IoC container
                 private readonly _lifetime: ILifetime<IDestroyable>;
-                constructor(parentServices?: DescriptorMap<S>, lifetime?: ILifetime<IDestroyable>) {
+                constructor(parentServices: DescriptorMap<S> | null = null, lifetime?: ILifetime<IDestroyable>) {
-                    this._services = Object.create(parentServices ? parentServices : null) as DescriptorMap<S>;
+                    this._services = prototype(parentServices);
                     this._lifetimeManager = new LifetimeManager();
                     this._lifetime = lifetime ?? emptyLifetime();
                 }

src/main/ts/DescriptorImpl.ts +15 -6

+            import { ActivationError } from "./ActivationError";
             import { Descriptor, ILifetime, DepsMap, IActivationContext, DescriptorMap } from "./interfaces";
             import { each, key } from "./traits";
                     const resolve = <K extends keyof S>({ name, lazy, ...opts }: { name: K; lazy?: boolean; default?: S[K] | null; }) => {
                         if (lazy) {
-                            return () => "default" in opts ? context.resolve(name, opts.default) : context.resolve(name);
+                            return "default" in opts ?
+                                () => context.resolve(name, opts.default) :
+                                () => context.resolve(name);
                         } else {
-                            return "default" in opts ? context.resolve(name, opts.default) : context.resolve(name);
+                            return "default" in opts ?
+                                context.resolve(name, opts.default) :
+                                context.resolve(name);
                         }
                     };
-                    const makeRefs = (deps: typeof this._deps) => deps ?
+                    const deps = this._deps;
+                    const refs = deps ?
                         Object.keys(deps)
                             .map(k => {
                                 const ref = deps[k];
                             .reduce((a, p) => ({ ...a, ...p }), {}) :
                         {};
-                    const instance = this._factory.call(undefined, makeRefs(this._deps));
+                    try {
+                        const instance = (0,this._factory)(refs);
                         this._lifetime.store(instance, this._cleanup);
                         return instance;
+                    } catch(err) {
+                        context.fail(err);
+                    }
                 }

src/main/ts/LifetimeManager.ts +22 -13

                 }
             };
+            const noop = () => {};
+            const fail = (message: string) => {
+                throw new Error(message);
+            };
             const _emptySlot = Object.freeze({
                 has: () => false,
-                initialize: () => void (0),
+                initialize: noop,
+                get: fail("The specified item isn't registered with a lifetime manager"),
-                get: () => {
+                store: noop,
-                    throw new Error("The specified item isn't registered with this lifetime manager");
-                },
-                store: () => void (0)
+                remove: noop
             });
             const _unknonwSlot = Object.freeze({
                 }
             });
-            let nextId = 0;
-            const singletons: { [K: string]: unknown } = {};
             const pendingSlot = <T>(store: (item: T) => void) => ({
                 has: () => false,
                 store
             });
-            const noop = () => void(0);
             const valueSlot = <T>(value: T, cleanup: (item: T) => void) => ({
                 has: () => true,
                 }
             });
+            const singletons: { [K: string]: unknown } = {};
             export class LifetimeManager implements ILifetimeManager {
                 private _destroyed = false;
                     };
                 }
+                remove(cookie: string) {
+                    delete this._slots[cookie];
+                }
                 private _assertNotDestroyed() {
                     if (this._destroyed)
                         throw new Error("The lifetime manager is destroyed");
                 destroy() {
                     if (!this._destroyed) {
                         this._destroyed = true;
-                        this._cleanup.forEach(safeCall);
+                        Object.values(this._slots).forEach(({clean}) => )
-                        this._cleanup.length = 0;
                     }
                 }
             };
             export const hierarchyLifetime = <T>(): ILifetime<T> => {
+                // TODO: вот здесь ошибка, при первой активации сервиса будет получен и
+                // привязан lifetime из дочернего контейнера, при активации через второй
+                // дочерний контейнера это приведет к ошибке, точнее будет взят экземпляр
+                // из первого контейнера.
                 let _lifetime: ILifetime<T> = _unknownLifetime;
                 return {
                     initialize(context: ILifetimeContext) {

src/main/ts/interfaces.ts +4 -5

             /** The context used to initialize lifetime instance {@linkcode ILifetime} */
             export interface ILifetimeContext {
-                createLifetime<T>(): ILifetime<T>;
+                contextSlot<T>(slotId: string): ILifetimeSlot<T>;
-                createContainerLifetime<T>(): ILifetime<T>;
+                containerSlot<T>(slotId: string): ILifetimeSlot<T>;
             }
             export interface IActivationContext<S> extends ILifetimeContext, ServiceLocator<S> {
                 register<K extends keyof S>(name: K, service: DescriptorMap<S>[K]): void;
+                fail(error: unknown): never;
             }
             /**
                 resolve<K extends keyof S, T>(name: K, def: T): NonNullable<S[K]> | T;
             }
-            export interface LifetimeContainer {
-                createLifetime<T>(): ILifetime<T>;
             export interface IContainerBuilder<S, U extends keyof S> {
                 createServiceBuilder<K extends U>(name: K):

src/main/ts/traits.ts +4 -1

@@ -46,4 +46,7 export const oid = <T extends object>(in
46	const val = (instance as OidSlot)[_oid];	46	const val = (instance as OidSlot)[_oid];
47		47
48	return val ? val : ((instance as OidSlot)[_oid] = `oid_${++_nextOid}`);	48	return val ? val : ((instance as OidSlot)[_oid] = `oid_${++_nextOid}`);
49	}; No newline at end of file	49	};
		50
		51	export const prototype = <T extends object>(instance: T \| null): T =>
		52	Object.create(instance) as T; No newline at end of file

src/tsconfig.json +2 -2

                     "listFiles": true,
                     "strict": true,
                     "types": [],
-                    "target": "ES5",
+                    "target": "ES2018",
-                    "lib": ["es5", "es2015.promise", "es2015.symbol", "es2015.iterable", "dom", "scripthost"]
+                    "lib": ["ES2018", "DOM", "ScriptHost"]
                 }
             }

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