Options
All
  • Public
  • Public/Protected
  • All
Menu

mahobin

Index

Enumerations

Classes

Interfaces

Type aliases

Variables

Type aliases

ContainerContents

ContainerContents<T>: T extends Container<infer R> ? R : never

Type parameters

  • T

ContainerFactoryFnContents

ContainerFactoryFnContents<T>: T extends () => Promise<Container<infer R>> ? R : T extends () => Container<infer R> ? R : never

Helper type for inferring container contents from function.

example
const createContainer = () => {
  return Container.create().register({
    key: 'now',
    factory: () => new Date()
  })
};

// {now: Date}
export type ContainerContents = ContainerFactoryFnContents<typeof createContainer>

Type parameters

  • T

ContainerKey

ContainerKey: string | symbol | number

Factory

Factory<T, R>: (items: R) => T

Type parameters

Type declaration

    • (items: R): T

    • Parameters

      • items: R

      Returns T

InjectionParams

InjectionParams<Resolvers, Key>: Resolvers[Key] extends Resolver<any, infer R> ? Partial<R> : never

Type parameters

MaybePromise

MaybePromise<T>: T | Promise<T>

Type parameters

  • T

ResolvedResolver

ResolvedResolver<T>: T extends Pick<ResolverParams<any, infer S, any>, "factory"> ? Awaited<S> : never

Type parameters

  • T

ResolvedResolversRecord

ResolvedResolversRecord<T>: { [ Key in keyof T]: ResolvedResolver<T[Key]> }

Type parameters

ResolverDisposer

ResolverDisposer<T>: (item: T) => MaybePromise<unknown>

Type parameters

  • T

Type declaration

ResolverFromParams

ResolverFromParams<T>: T extends ResolverParams<any, infer V, infer R> ? Resolver<V, R> : never

Type parameters

  • T

ResolverParamsValue

ResolverParamsValue<Key, Items, T>: Key extends keyof Items ? Items[Key] extends { [declarationSymbol]?: true } ? Omit<Items[Key], typeof declarationSymbol> : T : T

Type parameters

  • Key: ContainerKey | keyof Items

  • Items: Record<string, any> = Record<string, any>

  • T = any

ResolverRecordEntry

ResolverRecordEntry<Items>: Omit<ResolverParams<any, any, Items>, "key">

Type parameters

ResolversFromResolversRecord

ResolversFromResolversRecord<T>: { [ Key in keyof T]: T[Key] extends Omit<ResolverParams<any, infer V, infer R>, "key"> ? Resolver<V, R> : never }

Type parameters

ResolversMap

ResolversMap: {}

Type declaration

Variables

Const declarationSymbol

declarationSymbol: typeof declarationSymbol = ...

Generated using TypeDoc