Interface: DiBagApi

The immutable public entry surface used by DiBag and derived facades.

See

https://dany-fedorov.github.io/di-bag/agent/api-card.html#dibag-facade

Properties

createBuilder

createBuilder: () => Builder<never>;

Defined in: di-bag.ts:740

Begin an empty immutable graph; buildContainer creates its owning container, buildModule seals a reusable module.

Example

const container = DiBag.createBuilder().withServices({ greeting: () => 'hello' }).buildContainer();

createProvider

readonly createProvider: {
    <F extends (this: void, dependencies: never, factoryContext: FactoryContext) => any, ReturnKind extends FactoryReturnKind = 'auto-detect'>(factory: F & AutoOutput<ReturnType<NoInfer<F>>, NoInfer<ReturnKind>>, options: {
        readonly factoryReceivesContext: true;
    } & CheckedReturnKindOptions<ReturnType<NoInfer<F>>, ReturnKind>): Provider<ContextualFactory<F>, Readonly<{}>, readonly [], TokenDependencyContract, Acquired<ReturnType<F>, ReturnKind>>;
    <F extends FactoryType, ReturnKind extends FactoryReturnKind = 'auto-detect'>(factory: F & AutoOutput<ReturnType<NoInfer<F>>, NoInfer<ReturnKind>>, ...options: {} extends CheckedReturnKindOptions<ReturnType<NoInfer<F>>, ReturnKind> ? [
        options?: {
            readonly factoryReceivesContext?: never;
        } & CheckedReturnKindOptions<ReturnType<NoInfer<F>>, ReturnKind>
    ] : [
        options: {
            readonly factoryReceivesContext?: never;
        } & CheckedReturnKindOptions<ReturnType<NoInfer<F>>, ReturnKind>
    ]): Provider<F, Readonly<{}>, readonly [], TokenDependencyContract, Acquired<ReturnType<F>, ReturnKind>>;
};

Defined in: di-bag.ts:659

Create a provider from a named-dependency factory.

Call Signature

<F extends (this: void, dependencies: never, factoryContext: FactoryContext) => any, ReturnKind extends FactoryReturnKind = 'auto-detect'>(factory: F & AutoOutput<ReturnType<NoInfer<F>>, NoInfer<ReturnKind>>, options: {
    readonly factoryReceivesContext: true;
} & CheckedReturnKindOptions<ReturnType<NoInfer<F>>, ReturnKind>): Provider<ContextualFactory<F>, Readonly<{}>, readonly [], TokenDependencyContract, Acquired<ReturnType<F>, ReturnKind>>;

Create a provider from a named-dependency factory that also receives FactoryContext.

Type Parameters

Type Parameter	Description
`F`	The exact callback signature and output.
`ReturnKind`	How its output is acquired.

Parameters

Parameter	Description
`factory`	-
`options`	-

Call Signature

<F extends FactoryType, ReturnKind extends FactoryReturnKind = 'auto-detect'>(factory: F & AutoOutput<ReturnType<NoInfer<F>>, NoInfer<ReturnKind>>, ...options: {} extends CheckedReturnKindOptions<ReturnType<NoInfer<F>>, ReturnKind> ? [
    options?: {
        readonly factoryReceivesContext?: never;
    } & CheckedReturnKindOptions<ReturnType<NoInfer<F>>, ReturnKind>
] : [
    options: {
        readonly factoryReceivesContext?: never;
    } & CheckedReturnKindOptions<ReturnType<NoInfer<F>>, ReturnKind>
]): Provider<F, Readonly<{}>, readonly [], TokenDependencyContract, Acquired<ReturnType<F>, ReturnKind>>;

Create a provider from a named-dependency factory that also receives FactoryContext.

Type Parameters

Type Parameter	Description
`F`	The exact callback signature and output.
`ReturnKind`	How its output is acquired.

Parameters

Parameter	Description
`factory`	-
`...options`	-

Example

const config = DiBag.createProvider(() => ({ url: 'memory:' }), { factoryReturnKind: 'sync-value' });

createProviderFromClass

readonly createProviderFromClass: <const Dependencies extends readonly DependencyReference[], ServiceClass extends new (...arguments_: TokenArguments<NoInfer<Dependencies>>) => unknown, ReturnKind extends FactoryReturnKind = 'auto-detect'>(options: PositionalClassOptions<Dependencies, ServiceClass & PositionalFactoryArguments<TokenArguments<NoInfer<Dependencies>>, ConstructorParameters<NoInfer<ServiceClass>>> & NativeOutput<InstanceType<NoInfer<ServiceClass>>, NoInfer<ReturnKind>> & AutoOutput<InstanceType<NoInfer<ServiceClass>>, NoInfer<ReturnKind>> & SyncOutput<InstanceType<NoInfer<ServiceClass>>, NoInfer<ReturnKind>>, ReturnKind>) => Provider<() => InstanceType<ServiceClass>, Readonly<{}>, readonly [], ReferenceGraph<Dependencies>, Acquired<InstanceType<ServiceClass>, ReturnKind>>;

Defined in: di-bag.ts:680

Create a provider that constructs a class from positional dependencies.

Type Parameters

Type Parameter	Description
`Dependencies`	-
`ServiceClass`	-
`ReturnKind`	-

Parameters

Parameter	Description
`options`	-

Example

const portSymbol = Symbol('port');
const port = DiBag.createToken(portSymbol).forService<number>();
class Client { constructor(readonly port: number) {} }
const client = DiBag.createProviderFromClass({ dependencies: [port], serviceClass: Client });

createProviderFromFunction

readonly createProviderFromFunction: <const Dependencies extends readonly DependencyReference[], FactoryFunction extends PositionalFactoryFunction<NoInfer<Dependencies>, any, NoInfer<ReceivesContext>>, ReturnKind extends FactoryReturnKind = 'auto-detect', ReceivesContext extends boolean = false>(options: {
    readonly dependencies: Dependencies & DependencyTupleAdmission<Dependencies>;
    readonly factoryReceivesContext?: ReceivesContext;
    readonly factoryFunction: FactoryFunction & PositionalFactoryArguments<PositionalArguments<NoInfer<Dependencies>, NoInfer<ReceivesContext>>, Parameters<NoInfer<FactoryFunction>>> & AutoOutput<ReturnType<NoInfer<FactoryFunction>>, NoInfer<ReturnKind>>;
} & ContextSelection<NoInfer<ReceivesContext>> & CheckedPositionalReturnKindOptions<ReturnType<NoInfer<FactoryFunction>>, ReturnKind>) => Provider<OutputFactory<ReturnType<FactoryFunction>>, Readonly<{}>, readonly [], ReferenceGraph<Dependencies>, Acquired<ReturnType<FactoryFunction>, ReturnKind>>;

Defined in: di-bag.ts:669

Create a provider whose factory receives positional dependency values.

Create a provider by passing positional dependency values to a receiver-free function.

Type Parameters

Type Parameter	Description
`Dependencies`	The finite tuple of dependency references.
`FactoryFunction`	The exact callback signature and output.
`ReturnKind`	How the output is acquired.
`ReceivesContext`	Whether FactoryContext is appended after dependency values.

Parameters

Parameter	Description
`options`	-

Example

const portSymbol = Symbol('port');
const port = DiBag.createToken(portSymbol).forService<number>();
const client = DiBag.createProviderFromFunction({ dependencies: [port], factoryFunction: value => ({ port: value }) });

createProviderFromPlugin

readonly createProviderFromPlugin: CreateProviderFromPlugin;

Defined in: di-bag.ts:690

Create a provider from a versioned plugin descriptor. Its return kind must be uninspected or native-promise: plugin output cannot be inspected to determine the kind.

Example

const pluginDescriptor = { apiVersion: 1 as const, create: () => ({ run() {} }) };
const plugin = DiBag.createProviderFromPlugin({ dependencies: [], pluginDescriptor, factoryReturnKind: 'uninspected', isValidPluginOutput: (value): value is { run(): void } => typeof value === 'object' && value !== null });

createToken

readonly createToken: <const TokenSymbol extends symbol>(symbol: TokenSymbol & TokenKeyAdmission<TokenSymbol>, ...invalid: [TokenSymbol] extends [never] ? [TokenKeyAdmission<TokenSymbol>] : []) => {
    readonly forService: <Service>() => Token<TokenSymbol, Service>;
    readonly forCollectionOf: <Item>() => CollectionToken<TokenSymbol, Item>;
};

Defined in: di-bag.ts:699

Create a nominal token from a symbol.

Create a typed-token factory from the caller's canonical unique symbol. Reusing the same key and service type produces compatible handles; copied or fabricated objects are rejected at runtime.

Type Parameters

Type Parameter	Description
`TokenSymbol`	-

Parameters

Parameter	Description
`symbol`	An individually known unique symbol used as the runtime binding identity.
`...invalid`	-

Returns

A factory whose .forService<Service>() creates a single-service token and whose .forCollectionOf<Item>() creates a collection token.

Example

const clockKey = Symbol('clock');
const clock = DiBag.createToken(clockKey).forService<{ now(): number }>();

Example

const clockSymbol = Symbol('clock');
const clock = DiBag.createToken(clockSymbol).forService<{ now(): number }>();

lazy

lazy: <T extends TokenBase>(token: T & TokenTupleAdmission<readonly [T]>, ...invalid: [T] extends [never] ? [TokenTupleAdmission<readonly [T]>] : []) => LazyDependency<T>;

Defined in: di-bag.ts:732

Create a positional dependency supplied as a function that resolves the token when called.

Describe a positional dependency supplied as an on-demand lookup function. Each invocation follows the target lifetime and records its dependency edge then.

Type Parameters

Type Parameter	Description
`T`	-

Parameters

Parameter	Description
`token`	The genuine typed token to resolve lazily.
`...invalid`	-

Returns

An immutable lazy reference accepted by positional provider adapters.

Throws

DI_BAG_INVALID_TOKEN for a value that is not a genuine token.

Example

const clockKey = Symbol('clock');
const clock = DiBag.createToken(clockKey).forService<{ now(): number }>();
const stamp = DiBag.createProviderFromFunction({ dependencies: [DiBag.lazy(clock)], factoryFunction: getClock => () => getClock().now() });

optional

optional: <T extends TokenBase>(token: T & TokenTupleAdmission<readonly [T]> & OptionalTokenAdmission<T>, ...invalid: [T] extends [never] ? [TokenTupleAdmission<readonly [T]>] : []) => OptionalDependency<T>;

Defined in: di-bag.ts:721

Create a positional dependency that yields undefined only when the token is unregistered.

Describe a positional dependency that supplies undefined only when the token is unbound. A present undefined value and acquisition failures remain present dependency results.

Type Parameters

Type Parameter	Description
`T`	-

Parameters

Parameter	Description
`token`	The genuine typed token to read optionally.
`...invalid`	-

Returns

An immutable reference accepted by positional provider adapters.

Throws

DI_BAG_INVALID_TOKEN for a value that is not a genuine token; DI_BAG_WRONG_TOKEN_KIND when a collection token is used as an optional single-service dependency.

Example

const clockKey = Symbol('clock');
const clock = DiBag.createToken(clockKey).forService<{ now(): number }>();
const stamp = DiBag.createProviderFromFunction({ dependencies: [DiBag.optional(clock)], factoryFunction: source => source?.now() ?? 0 });

providerWithAcquisitionMetadata

readonly providerWithAcquisitionMetadata: {
    <ServiceProvider extends ProviderOrFactory, Describe extends (this: void, service: ProviderOutput<NoInfer<ServiceProvider>>) => object>(options: {
        readonly provider: ServiceProvider & PlainFactoryAdmission<NoInfer<ServiceProvider>>;
        readonly describeAcquisition: Describe & AcquisitionMetadataAdmission<ReturnType<Describe>>;
        readonly callbackReceives: 'exposed-service';
    }): Provider<ProviderFactory<ServiceProvider>, RetainedMetadata<ServiceProvider>, readonly [...ProviderAcquisitionMetadata<ServiceProvider>, Readonly<ReturnType<Describe>>], ProviderGraphContract<ServiceProvider>, ProviderAcquiredValue<ServiceProvider>>;
    <ServiceProvider extends ProviderOrFactory, Describe extends (this: void, service: Awaited<ProviderOutput<NoInfer<ServiceProvider>>>) => object>(options: {
        readonly provider: ServiceProvider & PlainFactoryAdmission<NoInfer<ServiceProvider>>;
        readonly describeAcquisition: Describe & AcquisitionMetadataAdmission<ReturnType<Describe>>;
        readonly callbackReceives: 'fulfilled-value';
    }): Provider<MappedProviderFactory<ProviderFactory<ServiceProvider>, Promise<Awaited<ProviderOutput<ServiceProvider>>>>, RetainedMetadata<ServiceProvider>, readonly [...ProviderAcquisitionMetadata<ServiceProvider>, Readonly<ReturnType<Describe>>], ProviderGraphContract<ServiceProvider>, Awaited<ProviderOutput<ServiceProvider>>>;
};

Defined in: di-bag.ts:781

Append one synchronous acquisition-metadata frame using the selected callback input.

Call Signature

<ServiceProvider extends ProviderOrFactory, Describe extends (this: void, service: ProviderOutput<NoInfer<ServiceProvider>>) => object>(options: {
    readonly provider: ServiceProvider & PlainFactoryAdmission<NoInfer<ServiceProvider>>;
    readonly describeAcquisition: Describe & AcquisitionMetadataAdmission<ReturnType<Describe>>;
    readonly callbackReceives: 'exposed-service';
}): Provider<ProviderFactory<ServiceProvider>, RetainedMetadata<ServiceProvider>, readonly [...ProviderAcquisitionMetadata<ServiceProvider>, Readonly<ReturnType<Describe>>], ProviderGraphContract<ServiceProvider>, ProviderAcquiredValue<ServiceProvider>>;

Append one synchronous acquisition-metadata frame using the exposed service.

Type Parameters

Type Parameter	Description
`ServiceProvider`	The plain factory or provider being decorated.
`Describe`	The synchronous metadata callback.

Parameters

Parameter	Description
`options`	The provider, callback, and exposed-service input selection.

Returns

A new frozen provider retaining the appended frame type.

Example

const observed = DiBag.providerWithAcquisitionMetadata({ provider: () => 1, callbackReceives: 'exposed-service', describeAcquisition: value => ({ value }) });

Call Signature

<ServiceProvider extends ProviderOrFactory, Describe extends (this: void, service: Awaited<ProviderOutput<NoInfer<ServiceProvider>>>) => object>(options: {
    readonly provider: ServiceProvider & PlainFactoryAdmission<NoInfer<ServiceProvider>>;
    readonly describeAcquisition: Describe & AcquisitionMetadataAdmission<ReturnType<Describe>>;
    readonly callbackReceives: 'fulfilled-value';
}): Provider<MappedProviderFactory<ProviderFactory<ServiceProvider>, Promise<Awaited<ProviderOutput<ServiceProvider>>>>, RetainedMetadata<ServiceProvider>, readonly [...ProviderAcquisitionMetadata<ServiceProvider>, Readonly<ReturnType<Describe>>], ProviderGraphContract<ServiceProvider>, Awaited<ProviderOutput<ServiceProvider>>>;

Append an acquisition metadata frame after awaiting the exposed service.

Type Parameters

Type Parameter	Description
`ServiceProvider`	The plain factory or provider being decorated.
`Describe`	The synchronous metadata callback for the fulfilled value.

Parameters

Parameter	Description
`options`	The provider, callback, and fulfilled-value input selection.

Returns

A new frozen provider exposing a Promise and retaining the appended frame type.

Example

const observed = DiBag.providerWithAcquisitionMetadata({ provider: async () => 1, callbackReceives: 'fulfilled-value', describeAcquisition: value => ({ value }) });

Throws

DI_BAG_INVALID_ARGUMENT for a malformed options object; DI_BAG_INVALID_ACQUISITION_METADATA for an invalid callback result; DI_BAG_INVALID_PROVIDER for an invalid provider.

Example

const observed = DiBag.providerWithAcquisitionMetadata({ provider: () => 1, callbackReceives: 'exposed-service', describeAcquisition: value => ({ value }) });

providerWithDisposal

readonly providerWithDisposal: <ServiceProvider extends ProviderOrFactory>(options: {
    readonly provider: ServiceProvider & PlainFactoryAdmission<NoInfer<ServiceProvider>>;
    readonly disposeService: (this: void, service: ProviderAcquiredValue<NoInfer<ServiceProvider>>) => void | Promise<void>;
}) => Provider<ProviderFactory<ServiceProvider>, RetainedMetadata<ServiceProvider>, ProviderAcquisitionMetadata<ServiceProvider>, ProviderGraphContract<ServiceProvider>, ProviderAcquiredValue<ServiceProvider>>;

Defined in: di-bag.ts:749

Add an ownership stage to a provider input.

Add an ownership stage whose disposer receives the provider input's acquired value. Earlier stages run later in reverse order.

Type Parameters

Type Parameter	Description
`ServiceProvider`	The plain factory or provider being decorated.

Parameters

Parameter	Description
`options`	The provider and disposer callback.

Returns

A new frozen provider retaining every earlier stage.

Example

const owned = DiBag.providerWithDisposal({ provider: () => ({ close() {} }), disposeService: service => service.close() });

Throws

DI_BAG_INVALID_ARGUMENT for a malformed options object or disposer; DI_BAG_INVALID_PROVIDER for an invalid provider.

Example

const owned = DiBag.providerWithDisposal({ provider: () => ({ close() {} }), disposeService: service => service.close() });

providerWithLifetime

readonly providerWithLifetime: <ServiceProvider extends ProviderOrFactory, const SelectedLifetime extends Lifetime, const Options extends object = {}>(options: {
    readonly provider: ServiceProvider & PlainFactoryAdmission<NoInfer<ServiceProvider>>;
    readonly lifetime: SelectedLifetime & LifetimeAdmission<SelectedLifetime>;
} & CheckedFacadeLifetimeOptions<NoInfer<SelectedLifetime>, Options>) => Provider<ProviderFactory<ServiceProvider>, RetainedMetadata<ServiceProvider>, ProviderAcquisitionMetadata<ServiceProvider>, LifetimeGraph<ProviderGraphContract<ServiceProvider>, SelectedLifetime, Options>, ProviderAcquiredValue<ServiceProvider>>;

Defined in: di-bag.ts:763

Return a provider with singleton, scoped, or transient caching. Providers are scoped per container by default; mark shared clients singleton when none of their dependencies are scoped.

Select one full caching policy. Only singleton may opt into scoped dependencies.

Type Parameters

Type Parameter	Description
`ServiceProvider`	The plain factory or provider being decorated.
`SelectedLifetime`	The individually known full lifetime literal.
`Options`	The inferred option-field record; only singleton accepts allowsScopedDependencies.

Parameters

Parameter	Description
`options`	The provider, lifetime, and optional singleton capture policy.

Returns

A new frozen provider carrying the selected graph contract.

Example

const cached = DiBag.providerWithLifetime({ provider: () => 1, lifetime: 'singleton:one-per-container-tree' });

Param

options

The provider, full lifetime, and optional deliberate scoped-capture allowance for singleton only.

Returns

A fresh immutable provider retaining every other provider stage.

Throws

DI_BAG_INVALID_ARGUMENT for a malformed options object, lifetime, or option; DI_BAG_INVALID_PROVIDER for an invalid provider.

Example

const createClient = () => ({ close() {} });
const client = DiBag.providerWithLifetime({ provider: DiBag.createProvider(() => createClient()), lifetime: 'singleton:one-per-container-tree' });

providerWithRegistrationMetadata

readonly providerWithRegistrationMetadata: <ServiceProvider extends ProviderOrFactory, AddedMetadata extends object>(options: {
    readonly provider: ServiceProvider & PlainFactoryAdmission<NoInfer<ServiceProvider>>;
    readonly registrationMetadata: AddedMetadata & MetadataKeys<NoInfer<ServiceProvider>, AddedMetadata>;
}) => Provider<ProviderFactory<ServiceProvider>, Readonly<RetainedMetadata<ServiceProvider> & AddedMetadata>, ProviderAcquisitionMetadata<ServiceProvider>, ProviderGraphContract<ServiceProvider>, ProviderAcquiredValue<ServiceProvider>>;

Defined in: di-bag.ts:772

Add noncolliding registration metadata without acquiring the service.

Add noncolliding registration metadata without acquiring the service. The metadata is copied and frozen.

Type Parameters

Type Parameter	Description
`ServiceProvider`	The plain factory or provider being decorated.
`AddedMetadata`	The metadata record appended to the retained contract.

Parameters

Parameter	Description
`options`	The provider and registration metadata.

Returns

A new frozen provider carrying the merged metadata.

Example

const registered = DiBag.providerWithRegistrationMetadata({ provider: () => 1, registrationMetadata: { owner: 'platform' } });

Throws

DI_BAG_INVALID_ARGUMENT for malformed metadata; DI_BAG_DUPLICATE_METADATA_KEY for a repeated key; DI_BAG_INVALID_PROVIDER for an invalid provider.

Example

const registered = DiBag.providerWithRegistrationMetadata({ provider: () => 1, registrationMetadata: { owner: 'platform' } });

providerWithTransformedService

readonly providerWithTransformedService: {
    <ServiceProvider extends ProviderOrFactory, Transform extends (this: void, service: NoInfer<CallbackReceives> extends 'fulfilled-value' ? Awaited<ProviderOutput<NoInfer<ServiceProvider>>> : ProviderOutput<NoInfer<ServiceProvider>>) => unknown, const CallbackReceives extends 'fulfilled-value' | 'exposed-service' = 'fulfilled-value'>(options: {
        readonly provider: ServiceProvider & PlainFactoryAdmission<NoInfer<ServiceProvider>>;
        readonly transformService: Transform & ([NoInfer<CallbackReceives>] extends ['fulfilled-value'] ? unknown : never);
        readonly callbackReceives: CallbackReceives;
        readonly transformReturnKind?: never;
    }): Provider<MappedProviderFactory<ProviderFactory<ServiceProvider>, Promise<Awaited<ReturnType<Transform>>>>, RetainedMetadata<ServiceProvider>, ProviderAcquisitionMetadata<ServiceProvider>, ProviderGraphContract<ServiceProvider>, Awaited<ReturnType<Transform>>>;
    <ServiceProvider extends ProviderOrFactory, Transform extends (this: void, service: ProviderOutput<NoInfer<ServiceProvider>>) => any, ReturnKind extends FactoryReturnKind = 'auto-detect'>(options: {
        readonly provider: ServiceProvider & PlainFactoryAdmission<NoInfer<ServiceProvider>>;
        readonly transformService: Transform & AutoOutput<ReturnType<NoInfer<Transform>>, NoInfer<ReturnKind>>;
        readonly callbackReceives: 'exposed-service';
    } & CheckedTransformReturnKindOptions<ReturnType<NoInfer<Transform>>, ReturnKind>): Provider<MappedProviderFactory<ProviderFactory<ServiceProvider>, ReturnType<Transform>>, RetainedMetadata<ServiceProvider>, ProviderAcquisitionMetadata<ServiceProvider>, ProviderGraphContract<ServiceProvider>, Acquired<ReturnType<Transform>, ReturnKind>>;
};

Defined in: di-bag.ts:790

Transform the selected callback input while retaining dependencies, metadata, lifetime and ownership stages.

Call Signature

<ServiceProvider extends ProviderOrFactory, Transform extends (this: void, service: NoInfer<CallbackReceives> extends 'fulfilled-value' ? Awaited<ProviderOutput<NoInfer<ServiceProvider>>> : ProviderOutput<NoInfer<ServiceProvider>>) => unknown, const CallbackReceives extends 'fulfilled-value' | 'exposed-service' = 'fulfilled-value'>(options: {
    readonly provider: ServiceProvider & PlainFactoryAdmission<NoInfer<ServiceProvider>>;
    readonly transformService: Transform & ([NoInfer<CallbackReceives>] extends ['fulfilled-value'] ? unknown : never);
    readonly callbackReceives: CallbackReceives;
    readonly transformReturnKind?: never;
}): Provider<MappedProviderFactory<ProviderFactory<ServiceProvider>, Promise<Awaited<ReturnType<Transform>>>>, RetainedMetadata<ServiceProvider>, ProviderAcquisitionMetadata<ServiceProvider>, ProviderGraphContract<ServiceProvider>, Awaited<ReturnType<Transform>>>;

Transform the selected fulfilled callback input while retaining every provider stage.

Type Parameters

Type Parameter	Description
`ServiceProvider`	The plain factory or provider being decorated.
`Transform`	The transformation callback.
`CallbackReceives`	The callback input mode; this overload requires fulfilled-value.

Parameters

Parameter	Description
`options`	The provider, callback, and fulfilled-value input selection.

Returns

A new frozen provider exposing the transformed Promise service.

Example

const mapped = DiBag.providerWithTransformedService({ provider: async () => 1, callbackReceives: 'fulfilled-value', transformService: value => String(value) });

Call Signature

<ServiceProvider extends ProviderOrFactory, Transform extends (this: void, service: ProviderOutput<NoInfer<ServiceProvider>>) => any, ReturnKind extends FactoryReturnKind = 'auto-detect'>(options: {
    readonly provider: ServiceProvider & PlainFactoryAdmission<NoInfer<ServiceProvider>>;
    readonly transformService: Transform & AutoOutput<ReturnType<NoInfer<Transform>>, NoInfer<ReturnKind>>;
    readonly callbackReceives: 'exposed-service';
} & CheckedTransformReturnKindOptions<ReturnType<NoInfer<Transform>>, ReturnKind>): Provider<MappedProviderFactory<ProviderFactory<ServiceProvider>, ReturnType<Transform>>, RetainedMetadata<ServiceProvider>, ProviderAcquisitionMetadata<ServiceProvider>, ProviderGraphContract<ServiceProvider>, Acquired<ReturnType<Transform>, ReturnKind>>;

Transform the exposed service while retaining dependencies, metadata, lifetime, and ownership.

Type Parameters

Type Parameter	Description
`ServiceProvider`	The plain factory or provider being decorated.
`Transform`	The transformation callback receiving the exposed service.
`ReturnKind`	The return policy for the transformation callback.

Parameters

Parameter	Description
`options`	The provider, exposed-service callback, and return policy when required.

Returns

A new frozen provider exposing the transformed service.

Example

const mapped = DiBag.providerWithTransformedService({ provider: () => 1, callbackReceives: 'exposed-service', transformService: value => String(value) });

Throws

DI_BAG_INVALID_ARGUMENT for a malformed options object or return policy; DI_BAG_INVALID_PROVIDER for an invalid provider.

Example

const mapped = DiBag.providerWithTransformedService({ provider: () => 1, callbackReceives: 'exposed-service', transformService: value => String(value) });

withConfiguration

withConfiguration: (options: ConfigurationOptions) => DiBagApi;

Defined in: di-bag.ts:710

Return a facade with inherited runtime settings and appended observers.

Parameters

Parameter	Description
`options`	-

Throws

DI_BAG_INVALID_ARGUMENT for a non-object, a runtime without isNativePromise, or malformed observers.

Example

const Observed = DiBag.withConfiguration({
  lifecycleObservers: [{ onLifecycleEvent: event => console.log(event.kind), onObserverFailure: failure => console.error(failure.error) }],
});

Interface: DiBagApi ​

See ​

Properties ​

createBuilder ​

Example ​

createProvider ​

Call Signature ​

Type Parameters ​

Parameters ​

Call Signature ​

Type Parameters ​

Parameters ​

Example ​

createProviderFromClass ​

Type Parameters ​

Parameters ​

Example ​

createProviderFromFunction ​

Type Parameters ​

Parameters ​

Example ​

createProviderFromPlugin ​

Example ​

createToken ​

Type Parameters ​

Parameters ​

Returns ​

Example ​

Example ​

lazy ​

Type Parameters ​

Parameters ​

Returns ​

Throws ​

Example ​

optional ​

Type Parameters ​

Parameters ​

Returns ​

Throws ​

Example ​

providerWithAcquisitionMetadata ​

Call Signature ​

Type Parameters ​

Parameters ​

Returns ​

Example ​

Call Signature ​

Type Parameters ​

Parameters ​

Returns ​

Example ​

Throws ​

Example ​

providerWithDisposal ​

Type Parameters ​

Parameters ​

Returns ​

Example ​

Throws ​

Example ​

providerWithLifetime ​

Type Parameters ​

Parameters ​

Returns ​

Example ​

Param ​

Returns ​

Throws ​

Example ​

providerWithRegistrationMetadata ​

Type Parameters ​

Parameters ​

Returns ​

Example ​

Throws ​

Example ​

providerWithTransformedService ​

Call Signature ​

Type Parameters ​

Interface: DiBagApi

See

Properties

createBuilder

Example

createProvider

Call Signature

Type Parameters

Parameters

Call Signature

Type Parameters

Parameters

Example

createProviderFromClass

Type Parameters

Parameters

Example

createProviderFromFunction

Type Parameters

Parameters

Example

createProviderFromPlugin

Example

createToken

Type Parameters

Parameters

Returns

Example

Example

lazy

Type Parameters

Parameters

Returns

Throws

Example

optional

Type Parameters

Parameters

Returns

Throws

Example

providerWithAcquisitionMetadata

Call Signature

Type Parameters

Parameters

Returns

Example

Call Signature

Type Parameters

Parameters

Returns

Example

Throws

Example

providerWithDisposal

Type Parameters

Parameters

Returns

Example

Throws

Example

providerWithLifetime

Type Parameters

Parameters

Returns

Example

Param

Returns

Throws

Example

providerWithRegistrationMetadata

Type Parameters

Parameters

Returns

Example

Throws

Example

providerWithTransformedService

Call Signature

Type Parameters