API docs: context.context

(constructor)(_parent, name)

Create a new context.

_debug

protected

Debugger

A debug function which can be overridden by subclasses.

_parent?

protected

Context

(Optional) Parent context

configResolver

protected

ConfigurationResolver

Configuration resolver

name

readonly

string

Name of the context

registry

protected

readonly

Map<string, Binding>

Key to binding map as the internal registry

scope

BindingScope

Scope for binding resolution

subscriptionManager

readonly

ContextSubscriptionManager

Manager for observer subscriptions

tagIndexer

protected

readonly

ContextTagIndexer

Indexer for bindings by tag

_findByTagIndex(tag)

protected

Find bindings by tag leveraging indexes

_mergeWithParent(childList, parentList)

protected

add(binding)

Add a binding to the context. If a locked binding already exists with the same key, an error will be thrown.

bind(key)

Create a binding with the given key in the context. If a locked binding already exists with the same key, an error will be thrown.

close()

Close the context: clear observers, stop notifications, and remove event listeners from its parent context.

configure(key)

Create a corresponding binding for configuration of the target bound by the given key in the context.

For example, ctx.configure('controllers.MyController').to({x: 1}) will create binding controllers.MyController:$config with value {x: 1}.

contains(key)

Check if a binding exists with the given key in the local context without delegating to the parent context

createView(filter, comparator, options)

Create a view of the context chain with the given binding filter

debug(args)

protected

Wrap the debug statement so that it always print out the context name as the prefix

emitError(err)

Emit an error event

emitEvent(type, event)

A strongly-typed method to emit context events

find(pattern)

Find bindings using a key pattern or filter function

findByTag(tagFilter)

Find bindings using the tag filter. If the filter matches one of the binding tags, the binding is included.

findOrCreateBinding(key, policy)

Find or create a binding for the given key

get(keyWithPath, session)

Get the value bound to the given key, throw an error when no value is bound for the given key.

get(keyWithPath, options)

Get the value bound to the given key, optionally return a (deep) property of the bound value.

getBinding(key)

Look up a binding by key in the context and its ancestors. If no matching binding is found, an error will be thrown.

getBinding(key, options)

Look up a binding by key in the context and its ancestors. If no matching binding is found and options.optional is not set to true, an error will be thrown.

getConfig(key, propertyPath, resolutionOptions)

Resolve configuration for the binding by key

getConfigAsValueOrPromise(key, propertyPath, resolutionOptions)

Get the value or promise of configuration for a given binding by key

getConfigSync(key, propertyPath, resolutionOptions)

Resolve configuration synchronously for the binding by key

getDebugNamespace()

protected

Get the debug namespace for the context class. Subclasses can override this method to supply its own namespace.

getOwnerContext(keyOrBinding)

Get the owning context for a binding or its key

getResolutionContext(binding)

Locate the resolution context for the given binding. Only bindings in the resolution context and its ancestors are visible as dependencies to resolve the given binding

getScopedContext(scope)

Get the context matching the scope

getSync(keyWithPath, session)

Get the synchronous value bound to the given key, optionally return a (deep) property of the bound value.

This method throws an error if the bound value requires async computation (returns a promise). You should never rely on sync bindings in production code.

getSync(keyWithPath, options)

Get the synchronous value bound to the given key, optionally return a (deep) property of the bound value.

This method throws an error if the bound value requires async computation (returns a promise). You should never rely on sync bindings in production code.

inspect(options)

Inspect the context and dump out a JSON object representing the context hierarchy

isBound(key)

Check if a key is bound in the context or its ancestors

isSubscribed(observer)

Check if an observer is subscribed to this context

isVisibleTo(ctx)

Check if this context is visible (same or ancestor) to the given one

on(eventName, listener)

The “bind” event is emitted when a new binding is added to the context. The “unbind” event is emitted when an existing binding is removed.

on(event, listener)

once(eventName, listener)

The “bind” event is emitted when a new binding is added to the context. The “unbind” event is emitted when an existing binding is removed.

once(event, listener)

setupConfigurationResolverIfNeeded()

protected

Set up the configuration resolver if needed

subscribe(observer)

Add a context event observer to the context

toJSON()

Create a plain JSON object for the context

unbind(key)

Unbind a binding from the context. No parent contexts will be checked.

unsubscribe(observer)

Remove the context event observer from the context