aurelia-dependency-injection

aurelia-dependency-injection

Version 1.5.2
Published 4 years ago
454 kB
2 dependencies
MIT license

Install

npm i aurelia-dependency-injection

yarn add aurelia-dependency-injection

pnpm add aurelia-dependency-injection

Overview

A lightweight, extensible dependency injection container for JavaScript.

Index

Variables

variable resolver

const resolver: {
    decorates?: (key: any) => key is { get(container: Container, key: any): any };
} & (() => any);

Functions

function all

all: <
    TBase,
    TImpl extends Impl<TBase> = Impl<TBase>,
    TArgs extends Args<TBase> = Args<TBase>
>(
    keyValue: any
) => (
    target: DependencyCtor<TBase, TImpl, TArgs> & { inject?: TArgs[number][] },
    _key: any,
    index: number
) => void;

function autoinject

autoinject: <TPotential>(
    potentialTarget?: TPotential
) => TPotential extends Injectable ? void : (target: Injectable) => void;

function factory

factory: <
    TBase,
    TImpl extends Impl<TBase> = Impl<TBase>,
    TArgs extends Args<TBase> = Args<TBase>
>(
    keyValue: any
) => (
    target: DependencyCtor<TBase, TImpl, TArgs> & { inject?: TArgs[number][] },
    _key: any,
    index: number
) => void;

function getDecoratorDependencies

getDecoratorDependencies: <
    TBase,
    TImpl extends Impl<TBase> = Impl<TBase>,
    TArgs extends Args<TBase> = Args<TBase>
>(
    target: DependencyCtor<TBase, TImpl, TArgs> & { inject?: TArgs[number][] }
) => TArgs[number][];

function inject

inject: <
    TBase,
    TImpl extends Impl<TBase> = Impl<TBase>,
    TArgs extends Args<TBase> = Args<TBase>
>(
    ...rest: TArgs[number][]
) => any;

function invokeAsFactory

invokeAsFactory: <TBase, TImpl extends Impl<TBase>, TArgs extends Args<TBase>>(
    potentialTarget?: DependencyCtor<TBase, TImpl, TArgs>
) => void | ((target: DependencyCtor<TBase, TImpl, TArgs>) => void);

function invoker

invoker: <TBase, TImpl extends Impl<TBase>, TArgs extends Args<TBase>>(
    value: Invoker<TBase, TImpl, TArgs>
) => (target: DependencyCtor<TBase, TImpl, TArgs>) => void;

function lazy

lazy: <
    TBase,
    TImpl extends Impl<TBase> = Impl<TBase>,
    TArgs extends Args<TBase> = Args<TBase>
>(
    keyValue: any
) => (
    target: DependencyCtor<TBase, TImpl, TArgs> & { inject?: TArgs[number][] },
    _key: any,
    index: number
) => void;

function newInstance

newInstance: <
    TBase,
    TImpl extends Impl<TBase> = Impl<TBase>,
    TArgs extends Args<TBase> = Args<TBase>
>(
    asKeyOrTarget?: PrimitiveOrDependencyCtor<TBase, TImpl, TArgs> & {
        inject?: TArgs[number][];
    },
    ...dynamicDependencies: TArgs[number][]
) => (
    target: DependencyCtor<TBase, TImpl, TArgs> & { inject?: TArgs[number][] },
    _key: any,
    index: number
) => void;

function optional

optional: <
    TBase,
    TImpl extends Impl<TBase> = Impl<TBase>,
    TArgs extends Args<TBase> = Args<TBase>
>(
    checkParentOrTarget?: boolean
) => (
    target: DependencyCtor<TBase, TImpl, TArgs> & { inject?: TArgs[number][] },
    _key: any,
    index: number
) => void;

function parent

parent: <
    TBase,
    TImpl extends Impl<TBase> = Impl<TBase>,
    TArgs extends Args<TBase> = Args<TBase>
>(
    target: DependencyCtor<TBase, TImpl, TArgs> & { inject?: TArgs[number][] },
    _key: any,
    index: number
) => void;

function registration

registration: <TBase, TImpl extends Impl<TBase>, TArgs extends Args<TBase>>(
    value: Registration<TBase, TImpl, TArgs>
) => (target: DependencyCtor<TBase, TImpl, TArgs>) => void;

function singleton

singleton: {
    (registerInChild?: boolean): any;
    <TBase, TImpl extends Impl<TBase>, TArgs extends Args<TBase>>(
        key?: PrimitiveOrDependencyCtor<TBase, TImpl, TArgs>,
        registerInChild?: boolean
    ): any;
};

function transient

transient: <TBase, TImpl extends Impl<TBase>, TArgs extends Args<TBase>>(
    key?: PrimitiveOrDependencyCtor<TBase, TImpl, TArgs>
) => (target: DependencyCtor<TBase, TImpl, TArgs>) => void;

Classes

class All

class All<
    TBase,
    TImpl extends Impl<TBase> = Impl<TBase>,
    TArgs extends Args<TBase> = Args<TBase>
> {}

constructor

constructor(key: PrimitiveOrDependencyCtor<TBase, TImpl, TArgs>);

method get

get: (container: Container) => TImpl[];

method of

static of: <
    TBase,
    TImpl extends Impl<TBase> = Impl<TBase>,
    TArgs extends Args<TBase> = Args<TBase>
>(
    key: PrimitiveOrDependencyCtor<TBase, TImpl, TArgs>
) => All<TBase, TImpl, TArgs>;

class Container

class Container {}

constructor

constructor(configuration?: ContainerConfiguration);

property instance

static instance: Container;

property parent

parent: Container;

property root

root: Container;

method autoRegister

autoRegister: {
    <
        TBase,
        TImpl extends Impl<TBase> = Impl<TBase>,
        TArgs extends Args<TBase> = Args<TBase>
    >(
        key: Primitive,
        fn: DependencyCtorOrFunctor<TBase, TImpl, TArgs>
    ): Resolver;
    <
        TBase,
        TImpl extends Impl<TBase> = Impl<TBase>,
        TArgs extends Args<TBase> = Args<TBase>
    >(
        key: DependencyCtor<TBase, TImpl, TArgs>,
        fn?: DependencyCtorOrFunctor<TBase, TImpl, TArgs>
    ): Resolver;
};

method autoRegisterAll

autoRegisterAll: (fns: DependencyCtor<any, any, any>[]) => void;

method createChild

createChild: () => Container;

method get

get: {
    <
        TBase,
        TImpl extends Impl<TBase> = Impl<TBase>,
        TArgs extends Args<TBase> = Args<TBase>
    >(
        key: PrimitiveOrDependencyCtor<TBase, TImpl, TArgs>
    ): ImplOrAny<TImpl>;
    <
        TBase,
        TImpl extends Impl<TBase> = Impl<TBase>,
        TArgs extends Args<TBase> = Args<TBase>
    >(
        key: typeof Container
    ): Container;
};

method getAll

getAll: <
    TBase,
    TImpl extends Impl<TBase> = Impl<TBase>,
    TArgs extends Args<TBase> = Args<TBase>
>(
    key: PrimitiveOrDependencyCtor<TBase, TImpl, TArgs>
) => ImplOrAny<TImpl>[];

method getResolver

getResolver: <
    TStrategyKey extends keyof StrategyState<TBase, TImpl, TArgs>,
    TBase,
    TImpl extends Impl<TBase> = Impl<TBase>,
    TArgs extends Args<TBase> = Args<TBase>
>(
    key: PrimitiveOrDependencyCtorOrFunctor<TBase, TImpl, TArgs>
) => StrategyResolver<TBase, TImpl, TArgs, TStrategyKey>;

method hasResolver

hasResolver: <
    TBase,
    TImpl extends Impl<TBase> = Impl<TBase>,
    TArgs extends Args<TBase> = Args<TBase>
>(
    key: PrimitiveOrDependencyCtor<TBase, TImpl, TArgs>,
    checkParent?: boolean
) => boolean;

method invoke

invoke: <
    TBase,
    TImpl extends Impl<TBase> = Impl<TBase>,
    TArgs extends Args<TBase> = Args<TBase>
>(
    fn: DependencyCtorOrFunctor<TBase, TImpl, TArgs>,
    dynamicDependencies?: TArgs[number][]
) => ImplOrAny<TImpl>;

method makeGlobal

makeGlobal: () => Container;

method registerAlias

registerAlias: <
    TBase,
    TImpl extends Impl<TBase> = Impl<TBase>,
    TArgs extends Args<TBase> = Args<TBase>
>(
    originalKey: PrimitiveOrDependencyCtor<TBase, TImpl, TArgs>,
    aliasKey: PrimitiveOrDependencyCtor<TBase, TImpl, TArgs>
) => Resolver;

method registerHandler

registerHandler: <
    TBase,
    TImpl extends Impl<TBase> = Impl<TBase>,
    TArgs extends Args<TBase> = Args<TBase>
>(
    key: PrimitiveOrDependencyCtor<TBase, TImpl, TArgs>,
    handler: (
        container?: Container,
        key?: PrimitiveOrDependencyCtor<TBase, TImpl, TArgs>,
        resolver?: Resolver
    ) => any
) => Resolver;

method registerInstance

registerInstance: <
    TBase,
    TImpl extends Impl<TBase> = Impl<TBase>,
    TArgs extends Args<TBase> = Args<TBase>
>(
    key: PrimitiveOrDependencyCtor<TBase, TImpl, TArgs>,
    instance?: TImpl
) => Resolver;

method registerResolver

registerResolver: <
    TBase,
    TImpl extends Impl<TBase> = Impl<TBase>,
    TArgs extends Args<TBase> = Args<TBase>
>(
    key: PrimitiveOrDependencyCtor<TBase, TImpl, TArgs>,
    resolver: Resolver
) => Resolver;

method registerSingleton

registerSingleton: {
    <
        TBase,
        TImpl extends Impl<TBase> = Impl<TBase>,
        TArgs extends Args<TBase> = Args<TBase>
    >(
        key: Primitive,
        fn: DependencyCtorOrFunctor<TBase, TImpl, TArgs>
    ): Resolver;
    <
        TBase,
        TImpl extends Impl<TBase> = Impl<TBase>,
        TArgs extends Args<TBase> = Args<TBase>
    >(
        key: DependencyCtor<TBase, TImpl, TArgs>,
        fn?: DependencyCtorOrFunctor<TBase, TImpl, TArgs>
    ): Resolver;
};

method registerTransient

registerTransient: {
    <
        TBase,
        TImpl extends Impl<TBase> = Impl<TBase>,
        TArgs extends Args<TBase> = Args<TBase>
    >(
        key: Primitive,
        fn: DependencyCtorOrFunctor<TBase, TImpl, TArgs>
    ): Resolver;
    <
        TBase,
        TImpl extends Impl<TBase> = Impl<TBase>,
        TArgs extends Args<TBase> = Args<TBase>
    >(
        key: DependencyCtor<TBase, TImpl, TArgs>,
        fn?: DependencyCtorOrFunctor<TBase, TImpl, TArgs>
    ): Resolver;
};

method setHandlerCreatedCallback

setHandlerCreatedCallback: <
    TBase,
    TImpl extends Impl<TBase> = Impl<TBase>,
    TArgs extends Args<TBase> = Args<TBase>
>(
    onHandlerCreated: (
        handler: InvocationHandler<TBase, TImpl, TArgs>
    ) => InvocationHandler<TBase, TImpl, TArgs>
) => void;

method unregister

unregister: (key: any) => void;

class Factory

class Factory<
    TBase,
    TImpl extends Impl<TBase> = Impl<TBase>,
    TArgs extends Args<TBase> = Args<TBase>
> {}

constructor

constructor(key: PrimitiveOrDependencyCtorOrFunctor<TBase, TImpl, TArgs>);

method get

get: (container: Container) => DependencyFunctor<TBase, TImpl, TArgs>;

method of

static of: <
    TBase,
    TImpl extends Impl<TBase> = Impl<TBase>,
    TArgs extends Args<TBase> = Args<TBase>
>(
    key: DependencyCtor<TBase, TImpl, TArgs>
) => Factory<TBase, TImpl, TArgs>;

class FactoryInvoker

class FactoryInvoker<
    TBase,
    TImpl extends Impl<TBase> = Impl<TBase>,
    TArgs extends Args<TBase> = Args<TBase>
> implements Invoker<TBase, TImpl, TArgs> {}

property instance

static instance: FactoryInvoker<any, any, Args<any>>;

method invoke

invoke: (
    container: Container,
    fn: DependencyCtorOrFunctor<TBase, TImpl, TArgs>,
    dependencies: TArgs
) => ImplOrAny<TImpl>;

method invokeWithDynamicDependencies

invokeWithDynamicDependencies: (
    container: Container,
    fn: DependencyCtorOrFunctor<TBase, TImpl, TArgs>,
    staticDependencies: TArgs[number][],
    dynamicDependencies: TArgs[number][]
) => ImplOrAny<TImpl>;

class InvocationHandler

class InvocationHandler<
    TBase,
    TImpl extends Impl<TBase>,
    TArgs extends Args<TBase>
> {}

constructor

constructor(
    fn: DependencyCtorOrFunctor<TBase, TImpl, TArgs>,
    invoker: Invoker<TBase, TImpl, TArgs>,
    dependencies: any[] | unknown[]
);

property dependencies

dependencies: any[] | unknown[];

property fn

fn: DependencyCtorOrFunctor<TBase, TImpl, TArgs>;

property invoker

invoker: Invoker<TBase, TImpl, TArgs>;

method invoke

invoke: (container: Container, dynamicDependencies?: TArgs[]) => TImpl;

class Lazy

class Lazy<
    TBase,
    TImpl extends Impl<TBase> = Impl<TBase>,
    TArgs extends Args<TBase> = Args<TBase>
> {}

constructor

constructor(key: PrimitiveOrDependencyCtor<TBase, TImpl, TArgs>);

method get

get: (container: Container) => () => ImplOrAny<TImpl>;

method of

static of: <
    TBase,
    TImpl extends Impl<TBase> = Impl<TBase>,
    TArgs extends Args<TBase> = Args<TBase>
>(
    key: PrimitiveOrDependencyCtor<TBase, TImpl, TArgs>
) => Lazy<TBase, TImpl, TArgs>;

class NewInstance

class NewInstance<
    TBase,
    TImpl extends Impl<TBase> = Impl<TBase>,
    TArgs extends Args<TBase> = Args<TBase>
> {}

constructor

constructor(
    key: PrimitiveOrDependencyCtorOrFunctor<TBase, TImpl, TArgs>,
    ...dynamicDependencies: TArgs[number][]
);

method as

as: (key: PrimitiveOrDependencyCtorOrFunctor<TBase, TImpl, TArgs>) => this;

method get

get: (container: Container) => ImplOrAny<TImpl>;

method of

static of: <
    TBase,
    TImpl extends Impl<TBase> = Impl<TBase>,
    TArgs extends Args<TBase> = Args<TBase>
>(
    key: PrimitiveOrDependencyCtorOrFunctor<TBase, TImpl, TArgs>,
    ...dynamicDependencies: TArgs[number][]
) => NewInstance<TBase, TImpl, TArgs>;

class Optional

class Optional<
    TBase,
    TImpl extends Impl<TBase> = Impl<TBase>,
    TArgs extends Args<TBase> = Args<TBase>
> {}

constructor

constructor(
    key: PrimitiveOrDependencyCtor<TBase, TImpl, TArgs>,
    checkParent?: boolean
);

method get

get: (container: Container) => TImpl;

method of

static of: <
    TBase,
    TImpl extends Impl<TBase> = Impl<TBase>,
    TArgs extends Args<TBase> = Args<TBase>
>(
    key: PrimitiveOrDependencyCtor<TBase, TImpl, TArgs>,
    checkParent?: boolean
) => Optional<TBase, TImpl, TArgs>;

class Parent

class Parent<
    TBase,
    TImpl extends Impl<TBase> = Impl<TBase>,
    TArgs extends Args<TBase> = Args<TBase>
> {}

constructor

constructor(key: PrimitiveOrDependencyCtor<TBase, TImpl, TArgs>);

method get

get: (container: Container) => TImpl;

method of

static of: <
    TBase,
    TImpl extends Impl<TBase> = Impl<TBase>,
    TArgs extends Args<TBase> = Args<TBase>
>(
    key: PrimitiveOrDependencyCtor<TBase, TImpl, TArgs>
) => Parent<TBase, TImpl, TArgs>;

class SingletonRegistration

class SingletonRegistration<
    TBase,
    TImpl extends Impl<TBase>,
    TArgs extends Args<TBase>
> implements Registration<TBase, TImpl, TArgs> {}

constructor

constructor(
    keyOrRegisterInChild?: PrimitiveOrDependencyCtor<TBase, TImpl, TArgs>,
    registerInChild?: boolean
);

method registerResolver

registerResolver: (
    container: Container,
    key: PrimitiveOrDependencyCtor<TBase, TImpl, TArgs>,
    fn: DependencyCtorOrFunctor<TBase, TImpl, TArgs>
) => Resolver;

class StrategyResolver

class StrategyResolver<
    TBase,
    TImpl extends Impl<TBase>,
    TArgs extends Args<TBase>,
    TStrategyKey extends keyof StrategyState<TBase, TImpl, TArgs>
> {}

constructor

constructor(strategy: keyof StrategyState<TBase, TImpl, TArgs>, state: any);

property state

state: any;

property strategy

strategy: keyof StrategyState<TBase, TImpl, TArgs>;

method get

get: (
    container: Container,
    key: PrimitiveOrDependencyCtor<TBase, TImpl, TArgs>
) => TImpl;

class TransientRegistration

class TransientRegistration<
    TBase,
    TImpl extends Impl<TBase>,
    TArgs extends Args<TBase>
> implements Registration<TBase, TImpl, TArgs> {}

constructor

constructor(key?: PrimitiveOrDependencyCtor<TBase, TImpl, TArgs>);

method registerResolver

registerResolver: (
    container: Container,
    key: PrimitiveOrDependencyCtor<TBase, TImpl, TArgs>,
    fn: DependencyCtorOrFunctor<TBase, TImpl, TArgs>
) => Resolver;

Interfaces

interface ContainerConfiguration

interface ContainerConfiguration {}

property handlers

handlers?: Map<any, any>;

property onHandlerCreated

onHandlerCreated?: (
    handler: InvocationHandler<any, any, any>
) => InvocationHandler<any, any, any>;

interface Invoker

interface Invoker<TBase, TImpl extends Impl<TBase>, TArgs extends Args<TBase>> {}

method invoke

invoke: (
    container: Container,
    fn: DependencyCtorOrFunctor<TBase, TImpl, TArgs>,
    dependencies: TArgs
) => ImplOrAny<TImpl>;

method invokeWithDynamicDependencies

invokeWithDynamicDependencies: (
    container: Container,
    fn: DependencyCtorOrFunctor<TBase, TImpl, TArgs>,
    staticDependencies: TArgs[number][],
    dynamicDependencies: TArgs[number][]
) => ImplOrAny<TImpl>;

interface Registration

interface Registration<
    TBase,
    TImpl extends Impl<TBase>,
    TArgs extends Args<TBase>
> {}

method registerResolver

registerResolver: (
    container: Container,
    key: PrimitiveOrDependencyCtor<TBase, TImpl, TArgs>,
    fn: DependencyCtorOrFunctor<TBase, TImpl, TArgs>
) => Resolver;

interface Resolver

interface Resolver {}

method get

get: (container: Container, key: any) => any;

interface StrategyState

interface StrategyState<
    TBase,
    TImpl extends Impl<TBase> = Impl<TBase>,
    TArgs extends Args<TBase> = Args<TBase>
> {}

property [Strategy.alias]

[Strategy.alias]: any;

property [Strategy.array]

[Strategy.array]: (
    | {
          get: (
              container: Container,
              key: PrimitiveOrDependencyCtor<TBase, TImpl, TArgs>
          ) => TImpl;
      }
    | TImpl
)[];

property [Strategy.function]

[Strategy.function]: StrategyFunctor<TBase, TImpl, TArgs>;

property [Strategy.instance]

[Strategy.instance]: TImpl;

property [Strategy.singleton]

[Strategy.singleton]: DependencyCtorOrFunctor<TBase, TImpl, TArgs>;

property [Strategy.transient]

[Strategy.transient]: DependencyCtorOrFunctor<TBase, TImpl, TArgs>;

Enums

enum Strategy

enum Strategy {
    instance = 0,
    singleton = 1,
    transient = 2,
    function = 3,
    array = 4,
    alias = 5,
}

member alias

alias = 5

member array

array = 4

member function

function = 3

member instance

instance = 0

member singleton

singleton = 1

member transient

transient = 2

Type Aliases

type Args

type Args<TBase> = CtorArgs<TBase> | FuncArgs<TBase>;

type CtorArgs

type CtorArgs<TBase> = TBase extends new (...args: infer TArgs) => infer Impl
    ? TArgs
    : any[];

type CtorImpl

type CtorImpl<TBase> = TBase extends new (...args: infer TArgs) => infer Impl
    ? Impl
    : any;

type DependencyCtor

type DependencyCtor<
    TBase,
    TImpl extends Impl<TBase> = Impl<TBase>,
    TArgs extends Args<TBase> = Args<TBase>
> = new (...args: TArgs) => TImpl | TBase;

type DependencyCtorOrFunctor

type DependencyCtorOrFunctor<
    TBase,
    TImpl extends Impl<TBase> = Impl<TBase>,
    TArgs extends Args<TBase> = Args<TBase>
> = DependencyCtor<TBase, TImpl, TArgs> | DependencyFunctor<TBase, TImpl, TArgs>;

type DependencyFunctor

type DependencyFunctor<
    TBase,
    TImpl extends Impl<TBase> = Impl<TBase>,
    TArgs extends Args<TBase> = Args<TBase>
> = (...args: TArgs) => TImpl | TBase;

type FuncArgs

type FuncArgs<TBase> = TBase extends (...args: infer TArgs) => infer Impl
    ? TArgs
    : any[];

type FuncReturns

type FuncReturns<TBase> = TBase extends (...args: infer TArgs) => infer Impl
    ? Impl
    : any;

type Impl

type Impl<TBase> = CtorImpl<TBase> | FuncReturns<TBase>;

type ImplOrAny

type ImplOrAny<TImpl> = unknown extends TImpl ? any : TImpl;

type Injectable

type Injectable = Function & {
    inject?: any[] | (() => any[]);
};

type IStrategy

type IStrategy = 1 | 2 | 3 | 4 | 5;

type Primitive

type Primitive =
    | boolean
    | string
    | number
    | symbol
    | object
    | ((...args: any[]) => any)
    | Array<any>;

type PrimitiveOrDependencyCtor

type PrimitiveOrDependencyCtor<
    TBase,
    TImpl extends Impl<TBase> = Impl<TBase>,
    TArgs extends Args<TBase> = Args<TBase>
> = DependencyCtor<TBase, TImpl, TArgs> | Primitive;

type PrimitiveOrDependencyCtorOrFunctor

type PrimitiveOrDependencyCtorOrFunctor<
    TBase,
    TImpl extends Impl<TBase> = Impl<TBase>,
    TArgs extends Args<TBase> = Args<TBase>
> =
    | DependencyCtor<TBase, TImpl, TArgs>
    | DependencyFunctor<TBase, TImpl, TArgs>
    | Primitive;

type StrategyFunctor

type StrategyFunctor<
    TBase,
    TImpl extends Impl<TBase> = Impl<TBase>,
    TArgs extends Args<TBase> = Args<TBase>
> = (
    container?: Container,
    ctor?: PrimitiveOrDependencyCtorOrFunctor<TBase, TImpl, TArgs>,
    strategyResolver?: any
) => TImpl;

Package Files (1)

dist/aurelia-dependency-injection.d.ts

Dependencies (2)

Peer Dependencies (0)

No peer dependencies.

Badge

To add a badge like this oneto your package's README, use the codes available below.

You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/aurelia-dependency-injection.

Markdown

[![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/aurelia-dependency-injection)

HTML

<a href="https://www.jsdocs.io/package/aurelia-dependency-injection"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>

Updated 1 year ago.
Package analyzed in 6849 ms.
Missing or incorrect documentation? Open an issue for this package.