Functions — github.com/adonisjs/fold

hub / github.com/adonisjs/fold / functions

Functions100 in github.com/adonisjs/fold

⨍ Functions 100◇ Types & classes 99

↓ 140 callersMethodmake

(value: string)

tests/container/swap.spec.ts:232

↓ 48 callersMethodbind

( binding: Binding, resolver: BindingResolver< KnownBindings, Binding extends AbstractCons

src/container.ts:350

↓ 44 callersMethodcall

* Call a method on an object by injecting its dependencies. The method * dependencies are resolved in the same manner as a class constructor * d

src/container.ts:258

↓ 37 callersMethodbindValue

( binding: Binding, value: Binding extends AbstractConstructor<infer A> ? A : Binding exte

src/container.ts:400

↓ 28 callersFunctioninject

()

src/decorators/inject.ts:127

↓ 27 callersMethodhasBinding

(binding: BindingKey)

src/container.ts:180

↓ 27 callersMethodsingleton

( binding: Binding, resolver: BindingResolver< KnownBindings, Binding extends AbstractCons

src/container.ts:456

↓ 26 callersMethodcreateResolver

* Create a container resolver to resolve bindings, or make classes. * * ```ts * const resolver = container.createResolver() * await resolv

src/container.ts:152

↓ 21 callersMethodmake

(value: string)

tests/container/make_class_via_inject.spec.ts:474

↓ 20 callersMethodalias

* Register an alias for a binding. The value can be a reference * to an existing binding or to a class constructor that will * instantiate to th

src/container.ts:281

↓ 16 callersMethodmake

( binding: Binding, runtimeValues?: any[], createError?: ErrorCreator )

src/container.ts:234

↓ 15 callersFunctionenqueue

(callback: Function)

src/utils.ts:67

↓ 15 callersMethodget

()

tests/container/swap.spec.ts:21

↓ 13 callersFunctionmoduleExpression

(expression: string, parentURL: URL | string)

src/module_expression.ts:52

↓ 11 callersMethodresolving

( binding: Binding, callback: Binding extends AbstractConstructor<infer A> ? HookCallback<KnownB

src/container.ts:583

↓ 10 callersMethodhasAllBindings

(bindings: BindingKey[])

src/container.ts:200

↓ 10 callersFunctionmoduleImporter

( importFn: () => Promise<{ default: Constructor<any> }>, method: string )

src/module_importer.ts:58

↓ 10 callersMethodswap

* Define a fake implementation for a binding or a class constructor. * Swaps have the highest priority when resolving dependencies * from the co

src/container.ts:491

↓ 9 callersFunctionparseBindingReference

( binding: string | [LazyImport<Constructor<any>> | Constructor<any>, any?] )

src/parse_binding_reference.ts:53

↓ 8 callersFunctioncontainerProvider

( binding: InspectableConstructor, property: string | symbol | number, resolver: ContainerResolver<any>,

src/provider.ts:37

↓ 8 callersMethodhandle

(args: string[])

tests/module_caller/to_callable.spec.ts:24

↓ 8 callersFunctionisClass

(value: unknown)

src/utils.ts:28

↓ 6 callersMethod#emit

* Notify emitter about binding resolution * * @param binding - The binding key that was resolved * @param value - The resolved value

src/resolver.ts:213

↓ 6 callersFunctionmoduleCaller

(target: Constructor<any>, method: string)

src/module_caller.ts:46

↓ 6 callersMethodprovide

* Provide a resolver to resolve the parent dependency * * @param resolver - Factory function that returns the contextual implementation *

src/contextual_bindings_builder.ts:86

↓ 6 callersMethodwhen

* Create a contextual builder to define contextual bindings. * Contextual bindings allow you to specify different implementations * for a depend

src/container.ts:616

↓ 5 callersMethodasksFor

* Specify the binding for which to register a custom * resolver. * * @param binding - The dependency class that the parent asks for * *

src/contextual_bindings_builder.ts:66

↓ 5 callersMethodcontextualBinding

* Add a contextual binding for a given class constructor. A * contextual binding takes a parent, parent's dependency and a callback * to resolve

src/container.ts:643

↓ 5 callersFunctionfirstWrapper

()

tests/enqueue.spec.ts:115

↓ 5 callersFunctionresolveDefault

(importPath: string, parentURL: URL | string)

src/utils.ts:171

↓ 5 callersFunctionsecondWrapper

()

tests/enqueue.spec.ts:120

↓ 5 callersFunctionthirdWrapper

()

tests/enqueue.spec.ts:125

↓ 4 callersMethod#execHooks

* Execute hooks for a given binding * * @param binding - The binding key * @param value - The resolved value to pass to hooks

src/resolver.ts:226

↓ 4 callersMethodresolveFor

* Resolves binding in context of a parent. The method is same as * the "make" method, but instead takes a parent class * constructor. This is us

src/resolver.ts:484

↓ 3 callersMethodboot

()

tests/container/bindings.spec.ts:46

↓ 2 callersMethod#getBindingProvider

* Returns the provider for the class constructor * * @param binding - The class constructor to get the provider for

src/resolver.ts:179

↓ 2 callersMethodhandle

(args: string[])

tests/module_caller/to_handle_method.spec.ts:24

↓ 2 callersFunctioninitiateContainerInjections

* Initiating the "containerInjections" property on the target, which is assumed * to be the class constructor. * * @param target - The class constr

src/decorators/inject.ts:38

↓ 2 callersMethodrestore

* Restore binding by removing its swap * * @param binding - The class constructor to restore * * @example * ```ts * container.restor

src/container.ts:515

↓ 2 callersMethodrestoreAll

* Restore mentioned or all bindings by removing their swaps * * @param bindings - Optional array of class constructors to restore. If not provid

src/container.ts:535

↓ 1 callersMethod#getBindingResolver

* Returns the binding resolver for a parent and a binding. Returns * undefined when no contextual binding exists * * @param parent - The pare

src/resolver.ts:190

↓ 1 callersMethod#invalidBindingException

* Constructs exception for invalid binding value * * @param parent - The parent class that requested the binding * @param binding - The inval

src/resolver.ts:139

↓ 1 callersMethod#missingDependenciesException

* Constructs exception for binding with missing dependencies * * @param parent - The parent class that requested the binding * @param binding

src/resolver.ts:160

↓ 1 callersFunctioncreateDebuggingError

* Creating a debugging error that points to the source * using the @inject decorator * * @param original - The original error to extract stack trac

src/decorators/inject.ts:22

↓ 1 callersFunctiondefineConstructorInjections

* Defining the injections for the constructor of the class using * reflection * * @param target - The class constructor to define injections for *

src/decorators/inject.ts:57

↓ 1 callersFunctiondefineMethodInjections

* Defining the injections for the class instance method * * @param target - The class prototype * @param method - The method name to define injecti

src/decorators/inject.ts:81

↓ 1 callersMethodfind

()

benchmarks/services/users.ts:2

↓ 1 callersMethodhasBinding

(binding: BindingKey)

src/resolver.ts:442

↓ 1 callersFunctioninline

(resolver: Container<any>)

benchmarks/module_expression.ts:42

↓ 1 callersFunctioninline

(resolver: Container<any>)

benchmarks/module_importer.ts:43

↓ 1 callersFunctionnative

(resolver: Container<any>)

benchmarks/module_expression.ts:33

↓ 1 callersFunctionnative

(resolver: Container<any>)

benchmarks/module_importer.ts:34

↓ 1 callersFunctionrejectPromises

* Reject pending queue promises

src/utils.ts:103

↓ 1 callersFunctionresolvePromises

* Resolve pending queue promises

src/utils.ts:92

↓ 1 callersFunctionrunAsAsync

* Runs a function inside an async function. This ensures that synchronous * errors are handled in the same way a rejected promise is handled * * @p

src/utils.ts:39

↓ 1 callersMethoduseEmitter

* Define an emitter instance to use for container events * * @param emitter - Event emitter instance that implements emit method * * @exam

src/container.ts:129

Method#resolveFor

* Resolves binding in context of a parent. The method is same as * the "make" method, but instead takes a parent class * constructor. * *

src/resolver.ts:247

FunctionHomeController

()

tests/parse_binding_reference.spec.ts:46

Methodbar

(emitter: Emitter)

tests/container/make_class_via_inject.spec.ts:171

MethodbindValue

( binding: Binding, value: Binding extends AbstractConstructor<infer A> ? A : Binding exte

src/resolver.ts:630

Methodcall

* Call a method on an object by injecting its dependencies. The method * dependencies are resolved in the same manner as a class constructor * d

src/resolver.ts:566

Methodconstructor

* Initialize the container resolver with container bindings and options * * @param container - Object containing all container bindings, values,

src/resolver.ts:111

Methodconstructor

* Initialize the contextual bindings builder * * @param parent - The parent class constructor for the contextual binding * @param container -

src/contextual_bindings_builder.ts:47

Methodconstructor

* Initialize the container with optional configuration * * @param options - Optional container configuration including event emitter * * @

src/container.ts:114

Methodconstructor

()

tests/container/swap.spec.ts:30

Methodconstructor

(public db: Database)

tests/container/known_make_class.spec.ts:143

Methodconstructor

(public db: Database)

tests/container/make_class.spec.ts:142

Methodconstructor

(public db: Database)

tests/container/make_class_via_inject.spec.ts:24

Methodconstructor

(public config: Config)

tests/container/make_class_via_inject.spec.ts:57

Methodconstructor

(public db: Database)

tests/container/make_class_via_inject.spec.ts:108

Methodconstructor

(public hash: Hash)

tests/container/make_class_via_inject.spec.ts:295

Methodfind

(encryption: Encryption)

tests/container/make_class_via_inject.spec.ts:88

Methodfind

()

benchmarks/services/comments.ts:2

Methodfind

()

benchmarks/services/thread.ts:2

Methodfind

()

benchmarks/services/posts.ts:2

Functionfoo

()

tests/container/known_make_class.spec.ts:78

Functionfoo

()

tests/container/make_class.spec.ts:78

Methodfoo

()

tests/container/call_method.spec.ts:74

Methodfoo

(db: Database)

tests/container/make_class_via_inject.spec.ts:164

Methodget

()

tests/container/swap.spec.ts:39

Functionhandle

(...args: Args)

src/module_caller.ts:133

Functionhandle

(...args: Args)

src/module_expression.ts:177

Functionhandle

(...args: Args)

src/module_importer.ts:160

MethodhasAllBindings

(bindings: BindingKey[])

src/resolver.ts:465

FunctioninjectDecorator

(target: any, propertyKey?: string | symbol)

src/decorators/inject.ts:137

Methodmake

( binding: Binding, runtimeValues?: any[], createError?: ErrorCreator )

src/resolver.ts:535

Methodmake

(_: string)

tests/container/swap.spec.ts:238

Methodmake

(value: string)

tests/container/make_class_via_inject.spec.ts:299

Methodmake

(value: string)

tests/container/make_class_via_inject.spec.ts:331

Methodmake

(value: string)

tests/container/make_class_via_inject.spec.ts:396

MethodmakeUrl

()

tests/container/known_bindings.spec.ts:259

Functionparse

* Parses a module expression to extract the module import path * and the method to call on the default exported class. * * ```ts *

src/module_expression.ts:69

Methodshow

(user: UserService)

tests/container/swap.spec.ts:33

Methodstore

()

tests/resolver.spec.ts:88

FunctiontoCallable

* Converts the class reference to a callable function. Invoking this method * internally creates a new instance of the class using the container

src/module_caller.ts:76

FunctiontoCallable

* Converts the module expression to a callable function. Invoking this * method run internally import the module, create a new instance of the

src/module_expression.ts:108

FunctiontoCallable

* Converts the module import function to a callable function. Invoking this * method run internally import the module, create a new instance of t

src/module_importer.ts:92

FunctiontoHandleMethod

* Converts the class reference to an object with handle method. Invoking this * method internally creates a new instance of the class using the c

src/module_caller.ts:126

FunctiontoHandleMethod

* Converts the module expression to an object with handle method. Invoking the * handle method run internally imports the module, create a new in

src/module_expression.ts:168

FunctiontoHandleMethod

* Converts the module import function to an object with handle method. Invoking the * handle method run internally imports the module, create a n

src/module_importer.ts:151