implab/implabjs-di Files · src/main/ts/DescriptorImpl.ts

Working on container builder

cin - - Load All Authors

File last commit:

r5:83fa5814462d default


                r5:83fa5814462d

default

Download file

             DescriptorImpl.ts
        
                    83 lines
            
             | 2.6 KiB
            
                | video/mp2t
            
             |
                TypeScriptLexer
            
             / src / main / ts / DescriptorImpl.ts
          
                    History
                
                 |
                  Source
                 | Raw
                 |Copy content
                 |Copy permalink

        cin
    
Working on container builder

              r5
            
      import { Descriptor, ILifetime, ConfigurableKeys, DepsMap, Ref, IActivationContext } from "./interfaces";

        cin
    
working on fluent configuration

              r1
            
      import { ActivationContext } from "./ActivationContext";

        cin
    
Removed ContextResolver, added DescriptoBuilder.wants(...), dependencies are declared statically

              r4
            
      import { each, isKey, key } from "./traits";

        cin
    
working on fluent configuration

              r1
            
      export type RegistrationOverridesMap<S extends object> = { [k in ConfigurableKeys<S>]?: Descriptor<S, NonNullable<S[k]>> };

        cin
    
initial commit

              r0
            
      export interface DescriptorImplArgs<S extends object, T> {

        cin
    
working on fluent configuration

              r1
            
          lifetime: ILifetime<T>;

        cin
    
initial commit

              r0
            
        cin
    
Removed ContextResolver, added DescriptoBuilder.wants(...), dependencies are declared statically

              r4
            
          factory: (refs: Record<key, never>) => T;

        cin
    
initial commit

              r0
            
          cleanup?: (item: T) => void;

        cin
    
working on fluent configuration

              r1
            
          overrides?: RegistrationOverridesMap<S>;

        cin
    
Removed ContextResolver, added DescriptoBuilder.wants(...), dependencies are declared statically

              r4
            
          dependencies?: DepsMap<key, keyof S>;

        cin
    
initial commit

              r0
            
      }

        cin
    
working on fluent configuration

              r1
            
        cin
    
initial commit

              r0
            
      export class DescriptorImpl<S extends object, T> implements Descriptor<S, T> {

        cin
    
working on fluent configuration

              r1
            
          private readonly _overrides?: RegistrationOverridesMap<S>;

        cin
    
initial commit

              r0
            
        cin
    
working on fluent configuration

              r1
            
          private readonly _lifetime: ILifetime<T>;

        cin
    
initial commit

              r0
            
        cin
    
Removed ContextResolver, added DescriptoBuilder.wants(...), dependencies are declared statically

              r4
            
          private readonly _factory: (refs: Record<key, never>) => T;

        cin
    
initial commit

              r0
            
          private readonly _cleanup?: (item: T) => void;

        cin
    
Removed ContextResolver, added DescriptoBuilder.wants(...), dependencies are declared statically

              r4
            
          private readonly _deps?: DepsMap<key, keyof S>;

          constructor({ lifetime, factory, cleanup, overrides, dependencies }: DescriptorImplArgs<S, T>) {

              this._lifetime = lifetime;

              this._factory = factory;

              if (cleanup)

                  this._cleanup = cleanup;

              if (overrides)

                  this._overrides = overrides;

              if (dependencies)

                  this._deps = dependencies;

        cin
    
initial commit

              r0
            
          }

        cin
    
Working on container builder

              r5
            
          activate(context: IActivationContext<S>): T {

        cin
    
initial commit

              r0
            
              if (this._lifetime.has())

                  return this._lifetime.get();

              this._lifetime.initialize(context);

              if (this._overrides)

                  each(this._overrides, (v, k) => context.register(k, v));

        cin
    
Removed ContextResolver, added DescriptoBuilder.wants(...), dependencies are declared statically

              r4
            
              const resolve = <K extends keyof S, L extends boolean, D = never>({ name, lazy, ...opts }: Ref<K, L, D>) => {

                  if (lazy) {

                      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);

                  }

              };

        cin
    
initial commit

              r0
            
        cin
    
Working on container builder

              r5
            
              const makeRefs = (deps: typeof this._deps) => deps ?

        cin
    
Removed ContextResolver, added DescriptoBuilder.wants(...), dependencies are declared statically

              r4
            
                  Object.keys(deps)

                      .map(k => {

                          const ref = deps[k];

                          return isKey(ref) ?

                              { [k]: resolve({ name: ref }) } :

                              { [k]: resolve(ref) };

                      })

                      .reduce((a, p) => ({ ...a, ...p }), {} ) as Record<key, never>:

                  {} as Record<key, never>;

        cin
    
working on fluent configuration

              r1
            
        cin
    
Removed ContextResolver, added DescriptoBuilder.wants(...), dependencies are declared statically

              r4
            
              const instance = this._factory.call(undefined, makeRefs(this._deps));

        cin
    
initial commit

              r0
            
              this._lifetime.store(instance, this._cleanup);

              return instance;

          }

        cin
    
working on fluent configuration

              r1
            
        cin
    
initial commit

              r0
            
          toString() {

        cin
    
working on fluent configuration

              r1
            
              return `[object DescriptorImpl, lifetime=${String(this._lifetime)}]`;

        cin
    
initial commit

              r0
            
          }

      }

	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

cin Working on container builder	r5	import { Descriptor, ILifetime, ConfigurableKeys, DepsMap, Ref, IActivationContext } from "./interfaces";
cin working on fluent configuration	r1	import { ActivationContext } from "./ActivationContext";
cin Removed ContextResolver, added DescriptoBuilder.wants(...), dependencies are declared statically	r4	import { each, isKey, key } from "./traits";
cin working on fluent configuration	r1
		export type RegistrationOverridesMap<S extends object> = { [k in ConfigurableKeys<S>]?: Descriptor<S, NonNullable<S[k]>> };
cin initial commit	r0
		export interface DescriptorImplArgs<S extends object, T> {
cin working on fluent configuration	r1	lifetime: ILifetime<T>;
cin initial commit	r0
cin Removed ContextResolver, added DescriptoBuilder.wants(...), dependencies are declared statically	r4	factory: (refs: Record<key, never>) => T;
cin initial commit	r0
		cleanup?: (item: T) => void;

cin working on fluent configuration	r1	overrides?: RegistrationOverridesMap<S>;
cin Removed ContextResolver, added DescriptoBuilder.wants(...), dependencies are declared statically	r4
		dependencies?: DepsMap<key, keyof S>;
cin initial commit	r0	}

cin working on fluent configuration	r1
cin initial commit	r0	export class DescriptorImpl<S extends object, T> implements Descriptor<S, T> {

cin working on fluent configuration	r1	private readonly _overrides?: RegistrationOverridesMap<S>;
cin initial commit	r0
cin working on fluent configuration	r1	private readonly _lifetime: ILifetime<T>;
cin initial commit	r0
cin Removed ContextResolver, added DescriptoBuilder.wants(...), dependencies are declared statically	r4	private readonly _factory: (refs: Record<key, never>) => T;
cin initial commit	r0
		private readonly _cleanup?: (item: T) => void;

cin Removed ContextResolver, added DescriptoBuilder.wants(...), dependencies are declared statically	r4	private readonly _deps?: DepsMap<key, keyof S>;

		constructor({ lifetime, factory, cleanup, overrides, dependencies }: DescriptorImplArgs<S, T>) {
		this._lifetime = lifetime;
		this._factory = factory;
		if (cleanup)
		this._cleanup = cleanup;
		if (overrides)
		this._overrides = overrides;
		if (dependencies)
		this._deps = dependencies;
cin initial commit	r0	}

cin Working on container builder	r5	activate(context: IActivationContext<S>): T {
cin initial commit	r0
		if (this._lifetime.has())
		return this._lifetime.get();

		this._lifetime.initialize(context);

		if (this._overrides)
		each(this._overrides, (v, k) => context.register(k, v));

cin Removed ContextResolver, added DescriptoBuilder.wants(...), dependencies are declared statically	r4	const resolve = <K extends keyof S, L extends boolean, D = never>({ name, lazy, ...opts }: Ref<K, L, D>) => {
		if (lazy) {
		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);
		}
		};
cin initial commit	r0
cin Working on container builder	r5	const makeRefs = (deps: typeof this._deps) => deps ?
cin Removed ContextResolver, added DescriptoBuilder.wants(...), dependencies are declared statically	r4	Object.keys(deps)
		.map(k => {
		const ref = deps[k];
		return isKey(ref) ?
		{ [k]: resolve({ name: ref }) } :
		{ [k]: resolve(ref) };
		})
		.reduce((a, p) => ({ ...a, ...p }), {} ) as Record<key, never>:
		{} as Record<key, never>;
cin working on fluent configuration	r1
cin Removed ContextResolver, added DescriptoBuilder.wants(...), dependencies are declared statically	r4	const instance = this._factory.call(undefined, makeRefs(this._deps));
cin initial commit	r0
		this._lifetime.store(instance, this._cleanup);

		return instance;
		}

cin working on fluent configuration	r1
cin initial commit	r0	toString() {
cin working on fluent configuration	r1	return `[object DescriptorImpl, lifetime=${String(this._lifetime)}]`;
cin initial commit	r0	}
		}