ember-source

constructor

constructor(registry: Registry, options?: ContainerOptions);

property cache

cache: { [key: string]: object };

property factoryManagerCache

factoryManagerCache: {
    [key: string]: InternalFactoryManager<object, FactoryClass>;
};

property isDestroyed

isDestroyed: boolean;

property isDestroying

isDestroying: boolean;

property owner

readonly owner: InternalOwner;

property registry

readonly registry: Registry & DebugRegistry;

property validationCache

readonly validationCache: { [key: string]: boolean };

method destroy

destroy: () => void;

• A depth first traversal, destroying the container, its descendant containers and all their managed objects. destroy

method factoryFor

factoryFor: (fullName: FullName) => InternalFactoryManager<object> | undefined;

• Given a fullName, return the corresponding factory. The consumer of the factory is responsible for the destruction of any factory instances, as there is no way for the container to ensure instances are destroyed when it itself is destroyed.

  factoryFor

  Parameter fullName

  {any}

  Modifiers

  • @public

method finalizeDestroy

finalizeDestroy: () => void;

method lookup

lookup: (
    fullName: string,
    options?: RegisterOptions
) => InternalFactory<object> | object | undefined;

• Given a fullName return a corresponding instance. The default behavior is for lookup to return a singleton instance. The singleton is scoped to the container, allowing multiple containers to all have their own locally scoped singletons. ```javascript let registry = new Registry(); let container = registry.container(); registry.register('api:twitter', Twitter); let twitter = container.lookup('api:twitter'); twitter instanceof Twitter; // => true // by default the container will return singletons let twitter2 = container.lookup('api:twitter'); twitter2 instanceof Twitter; // => true twitter === twitter2; //=> true ``` If singletons are not wanted, an optional flag can be provided at lookup. ```javascript let registry = new Registry(); let container = registry.container(); registry.register('api:twitter', Twitter); let twitter = container.lookup('api:twitter', { singleton: false }); let twitter2 = container.lookup('api:twitter', { singleton: false }); twitter === twitter2; //=> false ``` lookup

  Parameter fullName

  Parameter options

  {any}

method ownerInjection

ownerInjection: () => {};

• Returns an object that can be used to provide an owner to a manually created instance. ownerInjection

  Returns

  { Object }

method reset

reset: (fullName: FullName) => void;

• Clear either the entire cache or just the cache for a particular key.

  reset

  Parameter fullName

  optional key to reset; if missing, resets everything

constructor

constructor(
    container: Container,
    factory: InternalFactory<T, C>,
    fullName: string,
    normalizedName: string
);

property class

readonly class: DebugFactory<T, C>;

property container

readonly container: Container;

property fullName

readonly fullName: string;

property injections

injections: { [key: string]: unknown };

property normalizedName

readonly normalizedName: string;

property owner

readonly owner: InternalOwner;

method create

create: (options?: Partial<T>) => T;

method toString

toString: () => string;

constructor

constructor(options?: RegistryOptions);

property fallback

readonly fallback: Registry;

property registrations

readonly registrations: Record<
    string,
    object | InternalFactory<object, FactoryClass>
>;

property resolver

resolver: Resolver;

property set

set?: <T>(obj: object, keyName: string, value: T, tolerant?: boolean) => T;

method container

container: (options?: ContainerOptions) => Container;

• Creates a container based on this registry.

  container

  Parameter options

  {Container} created container

method describe

describe: (fullName: FullName) => string;

• A hook that can be used to describe how the resolver will attempt to find the factory.

  For example, the default Ember .describe returns the full class name (including namespace) where Ember's resolver expects to find the fullName.

  describe

  Parameter fullName

  {string} described fullName

method getOption

getOption: <K extends keyof RegisterOptions>(
    fullName: FullName,
    optionName: K
) => RegisterOptions[K] | undefined;

method getOptions

getOptions: (fullName: FullName) => RegisterOptions | undefined;

method getOptionsForType

getOptionsForType: (type: string) => RegisterOptions | undefined;

method has

has: (fullName: FullName) => boolean;

• Given a fullName check if the container is aware of its factory or singleton instance.

  has

  Parameter fullName

  Parameter options

  Parameter

  {String} [options.source] the fullname of the request source (used for local lookups) {Boolean}

method isValidFullName

isValidFullName: (fullName: string) => fullName is `${string}:${string}`;

method knownForType

knownForType: <T extends string>(type: T) => KnownForTypeResult<T>;

• knownForType

  Parameter type

  the type to iterate over

method makeToString

makeToString: (factory: InternalFactory<object>, fullName: FullName) => string;

• makeToString

  Parameter factory

  Parameter fullName

  {function} toString function

method normalize

normalize: (fullName: FullName) => FullName;

• Normalize a fullName based on the application's conventions

  normalize

  Parameter fullName

  {string} normalized fullName

method normalizeFullName

normalizeFullName: (fullName: FullName) => FullName;

• A hook to enable custom fullName normalization behavior

  normalizeFullName

  Parameter fullName

  {string} normalized fullName

method options

options: (fullName: FullName, options: RegisterOptions) => void;

• options

  Parameter fullName

  Parameter options

method optionsForType

optionsForType: (type: string, options: RegisterOptions) => void;

• Allow registering options for all factories of a type.

  ```javascript let registry = new Registry(); let container = registry.container();

  // if all of type connection must not be singletons registry.optionsForType('connection', { singleton: false });

  registry.register('connection:twitter', TwitterConnection); registry.register('connection:facebook', FacebookConnection);

  let twitter = container.lookup('connection:twitter'); let twitter2 = container.lookup('connection:twitter');

  twitter === twitter2; // => false

  let facebook = container.lookup('connection:facebook'); let facebook2 = container.lookup('connection:facebook');

  facebook === facebook2; // => false ```

  optionsForType

  Parameter type

  Parameter options

method register

register: {
    (
        fullName: FullName,
        factory: object,
        options: RegisterOptions & { instantiate: false }
    ): void;
    <T extends object, C extends object | FactoryClass>(
        fullName: `${string}:${string}`,
        factory: InternalFactory<T, C>,
        options?: RegisterOptions
    ): void;
};

• Registers a factory for later injection.

  Example:

  ```javascript let registry = new Registry();

  registry.register('model:user', Person, {singleton: false }); registry.register('fruit:favorite', Orange); registry.register('communication:main', Email, {singleton: false}); ```

  register

  Parameter fullName

  Parameter factory

  Parameter options

method resolve

resolve: (fullName: FullName) => InternalFactory<object> | object | undefined;

• Given a fullName return the corresponding factory.

  By default resolve will retrieve the factory from the registry.

  ```javascript let registry = new Registry(); registry.register('api:twitter', Twitter);

  registry.resolve('api:twitter') // => Twitter ```

  Optionally the registry can be provided with a custom resolver. If provided, resolve will first provide the custom resolver the opportunity to resolve the fullName, otherwise it will fallback to the registry.

  ```javascript let registry = new Registry(); registry.resolver = function(fullName) { // lookup via the module system of choice };

  // the twitter factory is added to the module system registry.resolve('api:twitter') // => Twitter ```

  resolve

  Parameter fullName

  {Function} fullName's factory

method unregister

unregister: (fullName: FullName) => void;

• Unregister a fullName

  ```javascript let registry = new Registry(); registry.register('model:user', User);

  registry.resolve('model:user').create() instanceof User //=> true

  registry.unregister('model:user') registry.resolve('model:user') === undefined //=> true ```

  unregister

  Parameter fullName

constructor

constructor(registry: Registry, options?: ContainerOptions);

property cache

cache: { [key: string]: object };

property factoryManagerCache

factoryManagerCache: {
    [key: string]: InternalFactoryManager<object, FactoryClass>;
};

property isDestroyed

isDestroyed: boolean;

property isDestroying

isDestroying: boolean;

property owner

readonly owner: InternalOwner;

property registry

readonly registry: Registry & DebugRegistry;

property validationCache

readonly validationCache: { [key: string]: boolean };

method destroy

destroy: () => void;

• A depth first traversal, destroying the container, its descendant containers and all their managed objects. destroy

method factoryFor

factoryFor: (fullName: FullName) => InternalFactoryManager<object> | undefined;

• Given a fullName, return the corresponding factory. The consumer of the factory is responsible for the destruction of any factory instances, as there is no way for the container to ensure instances are destroyed when it itself is destroyed.

  factoryFor

  Parameter fullName

  {any}

  Modifiers

  • @public

method finalizeDestroy

finalizeDestroy: () => void;

method lookup

lookup: (
    fullName: string,
    options?: RegisterOptions
) => InternalFactory<object> | object | undefined;

• Given a fullName return a corresponding instance. The default behavior is for lookup to return a singleton instance. The singleton is scoped to the container, allowing multiple containers to all have their own locally scoped singletons. ```javascript let registry = new Registry(); let container = registry.container(); registry.register('api:twitter', Twitter); let twitter = container.lookup('api:twitter'); twitter instanceof Twitter; // => true // by default the container will return singletons let twitter2 = container.lookup('api:twitter'); twitter2 instanceof Twitter; // => true twitter === twitter2; //=> true ``` If singletons are not wanted, an optional flag can be provided at lookup. ```javascript let registry = new Registry(); let container = registry.container(); registry.register('api:twitter', Twitter); let twitter = container.lookup('api:twitter', { singleton: false }); let twitter2 = container.lookup('api:twitter', { singleton: false }); twitter === twitter2; //=> false ``` lookup

  Parameter fullName

  Parameter options

  {any}

method ownerInjection

ownerInjection: () => {};

• Returns an object that can be used to provide an owner to a manually created instance. ownerInjection

  Returns

  { Object }

method reset

reset: (fullName: FullName) => void;

• Clear either the entire cache or just the cache for a particular key.

  reset

  Parameter fullName

  optional key to reset; if missing, resets everything

constructor

constructor(
    container: Container,
    factory: InternalFactory<T, C>,
    fullName: string,
    normalizedName: string
);

property class

readonly class: DebugFactory<T, C>;

property container

readonly container: Container;

property fullName

readonly fullName: string;

property injections

injections: { [key: string]: unknown };

property normalizedName

readonly normalizedName: string;

property owner

readonly owner: InternalOwner;

method create

create: (options?: Partial<T>) => T;

method toString

toString: () => string;

property cache

cache?: {
    [key: string]: object;
};

property factoryManagerCache

factoryManagerCache?: {
    [key: string]: InternalFactoryManager<any, any>;
};

property owner

owner?: InternalOwner;

property validationCache

validationCache?: {
    [key: string]: boolean;
};

property namespace

namespace: string | undefined;

property source

source: string | undefined;

property specifier

specifier: string;

method normalizeInjectionsHash

normalizeInjectionsHash: (hash: { [key: string]: LazyInjection }) => Injection[];

method validateInjections

validateInjections: (injections: Injection[]) => void;