async-injection 1.6.0 → 2.0.0

package/Changelog.md

@@ -1,3 +1,7 @@
+## 2.0.0 / 2024-08-06
+* Move typedefs up from lib/{cjs|esm} to just lib.
+* Remove binder.ts exports from index.ts
+
 ## 1.6.0 / 2024-05-23
 * Change internal meta-data constants from symbols to namespaced strings.
   This enables different compilation units to share a common Container. 

package/lib/cjs/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":";;;AACA,+CAAyC;AAAjC,yGAAA,SAAS,OAAA;AACjB,iDAAqF;AAA7E,uGAAA,MAAM,OAAA;AAAE,2GAAA,UAAU,OAAA;AAAE,yGAAA,QAAQ,OAAA;AAAE,8GAAA,aAAa,OAAA;AAAE,wGAAA,OAAO,OAAA;AAC5D,6CAAuF;AAA/C,6GAAA,cAAc,OAAA","sourcesContent":["export {Binder, SyncFactory, AsyncFactory, BindAs} from './binder.js';\nexport {Container} from './container.js';\nexport {Inject, Injectable, Optional, PostConstruct, Release} from './decorators.js';\nexport {ClassConstructor, InjectableId, InjectionToken, Injector} from './injector.js';\n"]}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":";;;AAAA,+CAAyC;AAAjC,yGAAA,SAAS,OAAA;AACjB,iDAAqF;AAA7E,uGAAA,MAAM,OAAA;AAAE,2GAAA,UAAU,OAAA;AAAE,yGAAA,QAAQ,OAAA;AAAE,8GAAA,aAAa,OAAA;AAAE,wGAAA,OAAO,OAAA;AAC5D,6CAAuF;AAA/C,6GAAA,cAAc,OAAA","sourcesContent":["export {Container} from './container.js';\nexport {Inject, Injectable, Optional, PostConstruct, Release} from './decorators.js';\nexport {ClassConstructor, InjectableId, InjectionToken, Injector} from './injector.js';\n"]}

package/lib/esm/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,SAAS,EAAC,MAAM,gBAAgB,CAAC;AACzC,OAAO,EAAC,MAAM,EAAE,UAAU,EAAE,QAAQ,EAAE,aAAa,EAAE,OAAO,EAAC,MAAM,iBAAiB,CAAC;AACrF,OAAO,EAAiC,cAAc,EAAW,MAAM,eAAe,CAAC","sourcesContent":["export {Binder, SyncFactory, AsyncFactory, BindAs} from './binder.js';\nexport {Container} from './container.js';\nexport {Inject, Injectable, Optional, PostConstruct, Release} from './decorators.js';\nexport {ClassConstructor, InjectableId, InjectionToken, Injector} from './injector.js';\n"]}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,SAAS,EAAC,MAAM,gBAAgB,CAAC;AACzC,OAAO,EAAC,MAAM,EAAE,UAAU,EAAE,QAAQ,EAAE,aAAa,EAAE,OAAO,EAAC,MAAM,iBAAiB,CAAC;AACrF,OAAO,EAAiC,cAAc,EAAW,MAAM,eAAe,CAAC","sourcesContent":["export {Container} from './container.js';\nexport {Inject, Injectable, Optional, PostConstruct, Release} from './decorators.js';\nexport {ClassConstructor, InjectableId, InjectionToken, Injector} from './injector.js';\n"]}

package/lib/{cjs/index.d.ts → index.d.ts}

@@ -1,4 +1,3 @@
-export { Binder, SyncFactory, AsyncFactory, BindAs } from './binder.js';
 export { Container } from './container.js';
 export { Inject, Injectable, Optional, PostConstruct, Release } from './decorators.js';
 export { ClassConstructor, InjectableId, InjectionToken, Injector } from './injector.js';

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "async-injection",
-	"version": "1.6.0",
+	"version": "2.0.0",
 	"description": "A robust lightweight dependency injection library for TypeScript.",
 	"author": "Frank Stock",
 	"license": "MIT",
@@ -22,10 +22,13 @@
 		".": {
 			"import": "./lib/esm/index.js",
 			"require": "./lib/cjs/index.js"
+		},
+		"./*": {
+			"types": "./lib/*.d.ts"
 		}
 	},
-	"types": "lib/esm/index.d.ts",
-	"typings": "lib/esm/index.d.ts",
+	"types": "lib/index.d.ts",
+	"typings": "lib/index.d.ts",
 	"directories": {
 		"lib": "lib"
 	},
@@ -38,7 +41,7 @@
 		"pretest": "npm run lint",
 		"test": "TS_NODE_PROJECT=./tsconfig-test.json  node --require ts-node/register --require tsconfig-paths/register node_modules/jasmine/bin/jasmine.js --config=jasmine.json",
 		"coverage": "rimraf coverage && rimraf ./nyc_output && nyc -e .ts -x \"**/*.spec.ts\" -x \"tst/*\" --reporter=text-summary --reporter=lcov npm run test",
-		"build": "npm run clean && tsc -p tsconfig.esm.json && tsc -p tsconfig.cjs.json && npm run _postbuild",
+		"build": "npm run clean && tsc -p tsconfig.base.json && tsc -p tsconfig.esm.json && tsc -p tsconfig.cjs.json && npm run _postbuild",
 		"_postbuild": "echo '{\"type\": \"module\"}' >lib/esm/package.json && echo '{\"type\": \"commonjs\"}' >lib/cjs/package.json",
 		"lint": "eslint 'src/**/*.ts'"
 	},
@@ -54,19 +57,19 @@
 		"@types/jasmine": "~5.1.4",
 		"@typescript-eslint/eslint-plugin": "~5.62.0",
 		"@typescript-eslint/parser": "~5.62.0",
-		"eslint": "~8.53.0",
+		"eslint": "~8.57.0",
 		"eslint-plugin-import": "~2.29.1",
 		"eslint-plugin-jsdoc": "~39.9.1",
 		"eslint-plugin-prefer-arrow": "~1.2.3",
-		"jasmine": "~5.1.0",
+		"jasmine": "~5.2.0",
 		"jasmine-console-reporter": "~3.1.0",
 		"nyc": "~15.1.0",
-		"reflect-metadata": "~0.1.14",
-		"rimraf": "~5.0.7",
+		"reflect-metadata": "~0.2.2",
+		"rimraf": "~5.0.10",
 		"source-map-support": "~0.5.21",
 		"ts-node": "~10.9.2",
 		"tsconfig-paths": "~4.2.0",
-		"tslib": "~2.6.2",
+		"tslib": "~2.6.3",
 		"typescript": "~4.9.5"
 	},
 	"nyc": {

package/lib/esm/async-factory-provider.d.ts

@@ -1,16 +0,0 @@
-import { BindableProvider } from './bindable-provider.js';
-import { AsyncFactory } from './binder.js';
-import { InjectableId, Injector } from './injector.js';
-import { State } from './state.js';
-/**
- * @inheritDoc
- * This specialization invokes it's configured Factory asynchronously and waits until it can provide the result.
- */
-export declare class AsyncFactoryBasedProvider<T> extends BindableProvider<T, AsyncFactory<T>> {
-    constructor(injector: Injector, id: InjectableId<T>, maker: AsyncFactory<T>);
-    /**
-     * @inheritDoc
-     * This specialization invokes it's configured Factory and provides the result (or invokes the error handler if necessary).
-     */
-    provideAsState(): State<T>;
-}

package/lib/esm/bindable-provider.d.ts

@@ -1,46 +0,0 @@
-import { AsyncFactory, BindAs, OnErrorCallback, OnSuccessCallback, SyncFactory } from './binder.js';
-import { ClassConstructor, InjectableId, Injector } from './injector.js';
-import { Provider } from './provider.js';
-/**
- * @inheritDoc
- * This abstraction is for Providers that can be additionally configured as Singletons and/or configured with error and/or success handling callback(s).
- */
-export declare abstract class BindableProvider<T, M = ClassConstructor<T> | SyncFactory<T> | AsyncFactory<T>> extends Provider<T> {
-    protected injector: Injector;
-    protected id: InjectableId<T>;
-    protected maker: M;
-    protected constructor(injector: Injector, id: InjectableId<T>, maker: M);
-    /**
-     * A user supplied success handling function.
-     * Default value is undefined.
-     */
-    protected successHandler?: OnSuccessCallback<T, any>;
-    /**
-     * A user supplied error handling function.
-     * Default value is undefined.
-     */
-    protected errorHandler?: OnErrorCallback<T, any>;
-    /**
-     * Invoked by the Binder to create chain-able configuration
-     *
-     * @see BindAs
-     */
-    makeBindAs(): BindAs<T, M>;
-    /**
-     * Encapsulate the logic of invoking any configured error handler, and processing it's result.
-     *
-     * @see OnErrorCallback
-     *
-     * @returns The object substituted by the callback (otherwise this method throws the appropriate error).
-     */
-    protected queryErrorHandler(err: unknown, obj?: T): T;
-    /**
-     * This is like a retry mechanism that uses the Provider's errorHandler (if any) to attempt recovery whenever the supplied Promise rejects.
-     * This method returns a Promise that rejects if recovery was not possible.
-     * If the supplied Promise resolves, then this method passes the result to the callback, and then resolve as whatever that callback returns.
-     *
-     * @param waitFor   The supplied Promise.
-     * @param cb    Callback to be invoked if the supplied Promise resolves.
-     */
-    protected makePromiseForObj<R>(waitFor: Promise<R>, cb: (result: R) => T): Promise<T>;
-}

package/lib/esm/binder.d.ts

@@ -1,106 +0,0 @@
-import { AbstractConstructor, ClassConstructor, InjectableId, Injector } from './injector.js';
-/**
- * Type definition for functions that return a value.
- * The function should return a valid value, but may throw an exception if it cannot.
- */
-export type SyncFactory<T> = (injector: Injector) => T;
-/**
- * Type definition for functions that return a Promise for a value.
- * The function *must* not throw and must return a valid Promise (e.g. pending, resolved, rejected).
- */
-export type AsyncFactory<T> = (injector: Injector) => Promise<T>;
-/**
- * You may bind an error handler which will be invoked, if the bound InjectableId could not be put into service.
- * An error handler *must* not throw, but may return an Error that will be propagated back up the call chain.
- *
- * @param binder   The Binder that experienced the error.
- * @param id   The identifier for what was trying to be made.
- * @param maker   The thing that made (or tried to provideAsState).  Will be one of type ClassConstructor, SyncFactory, or AsyncFactory, depending on how you registered the binding.
- * @param error   Identifies the problem that occurred.
- * @param value   If the 'maker' was able to create the thing, but it had an error during post construction, the made thing will be passed here.
- * @returns one of 3 results...
- * A substitute thing (kind of like a 'maker' do-over) which must be fully operational (e.g. any `@PostConstruct` will be ignored).
- * An alternate Error which will be propagated back up the call chain.
- * Undefined, which means the 'error' parameter will be propagated back up the call chain.
- */
-export type OnErrorCallback<T, M> = (injector: Injector, id: InjectableId<T>, maker: M, error: unknown, value?: T) => T | Error | void;
-/**
- * You may bind a success handler which will be invoked just before the bound InjectableId is put into service.
- * This is an alternative to the more preferred `@PostConstruct` decorator for scenarios when usage of that decorator is not feasible.
- * WARNING:
- * By registering a success handler, you override and nullify any `@PostConstruct` decorator on the class.
- * In such a scenario, the success handler should perform whatever care and feeding the class expected from the `@PostConstruct` decorator.
- * A success handler *must* not throw, but may return an Error that will be propagated back up the call chain.
- *
- * @param binder   The Binder that performed the construction.
- * @param id   The identifier for what was made.
- * @param maker   The thing that made.  Will be one of type ClassConstructor, SyncFactory, or AsyncFactory, depending on how you registered the binding.
- * @param value   The thing that was made.
- * @returns one of 3 results...
- * An Error which will be propagated back up the call chain.
- * Undefined, which means the object is ready to be placed into service.
- * A Promise that resolves to one of the above two values (undefined or Error).
- */
-export type OnSuccessCallback<T, M> = (value: T, injector: Injector, id: InjectableId<T>, maker: M) => Promise<Error | void> | Error | void;
-/**
- * An interface allowing binding of an error handler.
- *
- * @see OnErrorCallback
- */
-export interface BindErrHandler<T, M> {
-    onError(cb: OnErrorCallback<T, M>): void;
-}
-/**
- * An interface allowing binding of a post construction handler.
- *
- * @see OnSuccessCallback
- */
-export interface BindHandler<T, M> extends BindErrHandler<T, M> {
-    onSuccess(cb: OnSuccessCallback<T, M>): BindErrHandler<T, M>;
-}
-/**
- * @inheritDoc
- * This specialization also allows you to specify that the binding is 'Singleton' (e.g. only one in the system).
- */
-export interface BindAs<T, M> extends BindHandler<T, M> {
-    asSingleton(): BindHandler<T, M>;
-}
-/**
- * Bind Ids to producers.
- */
-export interface Binder extends Injector {
-    /**
-     * Bind an InjectableId to a constant value.
-     * Constants are by their very nature singleton, and are assumed to be error proof.
-     */
-    bindConstant<T>(id: InjectableId<T>, value: T): T;
-    /**
-     * Bind an InjectableId to a class (actually it's constructor).
-     * As a shortcut, you may use the class constructor as the 'id' (e.g. container.bindClass(A); ).
-     * The container will also invoke any `@PostConstruct` present on the class.
-     */
-    bindClass<T>(id: ClassConstructor<T>, constructor?: ClassConstructor<T>): BindAs<T, ClassConstructor<T>>;
-    bindClass<T>(id: string | symbol | AbstractConstructor<T> | InjectableId<T>, constructor: ClassConstructor<T>): BindAs<T, ClassConstructor<T>>;
-    /**
-     * Bind an InjectableId to a synchronous factory that will be invoked on demand when the object is needed.
-     * The factory should produce the needed value
-     * NOTE:  The container will not invoke any `@PostConstruct` present on the class, this is the responsibility of the factory.
-     */
-    bindFactory<T>(id: InjectableId<T>, factory: SyncFactory<T>): BindAs<T, SyncFactory<T>>;
-    /**
-     * Bind an InjectableId to an asynchronous factory that will be invoked on demand when the object is needed.
-     * The factory should produce the needed value (asynchronously of course).
-     * NOTE:  The container will not invoke any `@PostConstruct` present on the class, this is the responsibility of the factory.
-     * WARNING!!! The factory may not throw and must return a valid Promise (which can be pending, resolved, rejected, etc.).
-     */
-    bindAsyncFactory<T>(id: InjectableId<T>, factory: AsyncFactory<T>): BindAs<T, AsyncFactory<T>>;
-    /**
-     * This essentially pre creates/loads all *singleton* InjectableIds currently known to the Binder.
-     * This *may* be helpful if you wish to use Injector.get on a dependency tree that has asynchronous singletons within the tree.
-     *
-     * @param asyncOnly     Only resolve AsyncFactorys as well as any bound classes that have an asynchronous `@PostConstruct` decorator.  WARNING: If true, SyncFactorys will *not* be resolved even if they are Singletons.
-     * @param parentRecursion   If true and the the container has a parent, resolveIfSingleton will first be called for the parent
-     * @returns A Promise that resolves when all Singleton's have been resolved, OR rejects if one or more of the Singleton's failed to resolve.  NOTE: Rejection does not occur until all Singleton resolutions have settled, and the rejection reason/err will be a Map<InjectableId, Error>
-     */
-    resolveSingletons(asyncOnly?: boolean, parentRecursion?: boolean): Promise<this>;
-}

package/lib/esm/class-provider.d.ts

@@ -1,37 +0,0 @@
-import { BindableProvider } from './bindable-provider.js';
-import { ClassConstructor, InjectableId, Injector } from './injector.js';
-import { State } from './state.js';
-interface StateResolvingInjector extends Injector {
-    resolveState<T>(id: InjectableId<T>): State<T>;
-}
-/**
- * @inheritDoc
- * This specialization invokes it's configured class constructor synchronously and then scans for (and invokes) any @PostConstruct (which may be synchronous or asynchronous).
- */
-export declare class ClassBasedProvider<T> extends BindableProvider<T, ClassConstructor<T>> {
-    constructor(injector: StateResolvingInjector, id: InjectableId<T>, maker: ClassConstructor<T>);
-    /**
-     * @inheritDoc
-     * @see the class description for this Provider.
-     * This method is just a singleton guard, the real work is done by provideAsStateImpl.
-     */
-    provideAsState(): State<T>;
-    /**
-     * @inheritDoc
-     * This specialization returns undefined if 'asyncOnly' is true and there is no asynchronous PostConstruct annotation (since class constructors can never by asynchronous).
-     */
-    resolveIfSingleton(asyncOnly: boolean): Promise<T>;
-    /**
-     * Make a resolved or pending State that reflects any @PostConstruct annotations.
-     */
-    protected makePostConstructState(obj: T): State<T>;
-    /**
-     * This method collects the States of all the constructor parameters for our target class.
-     */
-    protected getConstructorParameterStates(): State[];
-    /**
-     * Gather the needed constructor parameters, invoke the constructor, and figure out what post construction needs done.
-     */
-    private provideAsStateImpl;
-}
-export {};

package/lib/esm/constant-provider.d.ts

@@ -1,10 +0,0 @@
-import { Provider } from './provider.js';
-import { State } from './state.js';
-/**
- * @inheritDoc
- * This specialization is always a Singleton.
- */
-export declare class ConstantProvider<T> extends Provider<T> {
-    constructor(constant: T);
-    provideAsState(): State<T>;
-}

package/lib/esm/constants.d.ts

@@ -1,8 +0,0 @@
-export declare const INJECTABLE_METADATA_KEY = "async-injection:INJECTABLE";
-export declare const INJECT_METADATA_KEY = "async-injection:INJECT";
-export declare const POSTCONSTRUCT_SYNC_METADATA_KEY = "async-injection:POSTCONSTRUCT_SYNC";
-export declare const POSTCONSTRUCT_ASYNC_METADATA_KEY = "async-injection:POSTCONSTRUCT_ASYNC";
-export declare const RELEASE_METADATA_KEY = "async-injection:RELEASE";
-export declare const OPTIONAL_METADATA_KEY = "async-injection:OPTIONAL";
-export declare const REFLECT_PARAMS = "design:paramtypes";
-export declare const REFLECT_RETURN = "design:returntype";

package/lib/esm/container.d.ts

@@ -1,89 +0,0 @@
-import { AsyncFactory, BindAs, Binder, SyncFactory } from './binder.js';
-import { AbstractConstructor, ClassConstructor, InjectableId, Injector } from './injector.js';
-import { Provider } from './provider.js';
-import { State } from './state.js';
-/**
- * Binder and Injector (aka Container) to handle (a)synchronous dependency management.
- */
-export declare class Container implements Binder {
-    protected parent?: Injector;
-    /**
-     * Create a new Container, with an optional parent Injector which will be searched if any given InjectableId is not bound within this Container.
-     */
-    constructor(parent?: Injector);
-    protected providers: Map<InjectableId<any>, Provider<any>>;
-    /**
-     * @inheritDoc
-     */
-    isIdKnown<T>(id: InjectableId<T>, ascending?: boolean): boolean;
-    /**
-     * @inheritDoc
-     */
-    get<T>(id: InjectableId<T>): T;
-    /**
-     * @inheritDoc
-     */
-    resolve<T>(id: InjectableId<T>): Promise<T>;
-    /**
-     * This method is not part of the Binding interface, because it is highly unusual.
-     * But that doesn't mean we can't imagine scenarios where you might require it.
-     *
-     * @param id    The id to be removed.
-     * @param ascending  If true, this will remove all bindings of the specified id all the way up the parent container chain (if it exists).
-     * @param releaseIfSingleton  If true, @Provider.releaseIfSingleton will be invoked before the binding is removed.
-     */
-    removeBinding<T>(id: InjectableId<T>, ascending?: boolean, releaseIfSingleton?: boolean): void;
-    /**
-     * @inheritDoc
-     */
-    bindConstant<T>(id: InjectableId<T>, value: T): T;
-    /**
-     * @inheritDoc
-     */
-    bindClass<T>(id: ClassConstructor<T>, constructor?: ClassConstructor<T>): BindAs<T, ClassConstructor<T>>;
-    bindClass<T>(id: string | symbol | AbstractConstructor<T> | InjectableId<T>, constructor: ClassConstructor<T>): BindAs<T, ClassConstructor<T>>;
-    /**
-     * @inheritDoc
-     */
-    bindFactory<T>(id: InjectableId<T>, factory: SyncFactory<T>): BindAs<T, SyncFactory<T>>;
-    /**
-     * @inheritDoc
-     */
-    bindAsyncFactory<T>(id: InjectableId<T>, factory: AsyncFactory<T>): BindAs<T, AsyncFactory<T>>;
-    /**
-     * @inheritDoc
-     */
-    resolveSingletons(asyncOnly?: boolean, parentRecursion?: boolean): Promise<this>;
-    /**
-     * As implied by the name prefix, this is a factored out method invoked only by the 'resolve' method.
-     * It makes searching our parent (if it exists) easier (and quicker) IF our parent is a fellow instance of Container.
-     */
-    protected resolveState<T>(id: InjectableId<T>): State<T>;
-    /**
-     * Convenience method to assist in releasing non-garbage-collectable resources that Singletons in this Container may have allocated.
-     * It will walk through all registered Providers (of this Container only), and invoke their @see Provider.releaseIfSingleton method.
-     * This method is not part of the Binding interface, because you normally only create (and release) Containers.
-     * NOTE:
-     * This *only* releases active/pending Singleton's that have already been created by this Container.
-     * The most likely use of this method would be when you have created a new child Container for a limited duration transaction, and you want to easily cleanup temporary resources.
-     * For example, your service object may need to know when it should unsubscribe from an RxJs stream (failure to do so can result in your Singleton not being garbage collected at the end of a transaction).
-     * In theory, you could handle all unsubscription and cleanup yourself, but the @Release decorator and this method are meant to simply make that easier.
-     */
-    releaseSingletons(): void;
-    /**
-     * Make a copy of this @see Container.
-     * This is an experimental feature!
-     * I have not thought through all the dark corners, so use at your own peril!
-     * Here are some notes:
-     *  The injector parameter for SyncFactory and AsyncFactory callbacks will be the Container invoking the factory.
-     *      So a factory that uses a parent closure instead of the supplied injector may get unexpected results.
-     *  The injector parameter for OnSuccess and OnError callbacks will be the Container performing the resolution.
-     *  Singletons are cloned at their *existing* state..
-     *      If resolved in "this" container, they will not be re-resolved for the clone.
-     *      If released by the clone, they will be considered released by "this" container.
-     *      If a singleton is currently being asynchronously constructed any callbacks will reference "this" Container, however both Containers should have no problem awaiting resolution.
-     *      If a singleton is not resolved when the container is cloned, then if both containers resolve, you will create *two* "singletons".
-     *      The way to avoid this last effect is to @see resolveSingletons
-     */
-    clone(clazz?: ClassConstructor<Container>): Container;
-}

package/lib/esm/decorators.d.ts

@@ -1,56 +0,0 @@
-import { InjectableId } from './injector.js';
-/**
- * Placed just before the class declaration, this class decorator applies metadata to the class constructor indicating that the user intends to bind the class into the container.
- * This decorator will throw if not placed on a class declaration, or if placed more than once on a class declaration.
- */
-export declare function Injectable(): ClassDecorator;
-/**
- * Placed just before a constructor parameter, this parameter decorator allows for specificity and control over the type of the type of Object that will be injected into the parameter.
- * In the absence of this decorator the container will use whatever is bound to a parameter's type (or throw an error if it is unable to recognize the type).
- *
- * @param id  The identifier of the bound type that should be injected.
- */
-export declare function Inject(id: InjectableId<any>): ParameterDecorator;
-/**
- * This is a helper function used by the container to retrieve the @Inject metadata for a specifically indexed constructor parameter
- *
- * @param target  The constructor function of the class (we don't allow @Inject on anything else).
- * @param parameterIndex    The ordinal index of the parameter in the constructor’s parameter list
- * @see Inject
- */
-export declare function _getInjectedIdAt(target: Function, parameterIndex: number): InjectableId<any>;
-/**
- * Placed just before a constructor parameter, this parameter decorator signals the container that it should supply the 'alt' constant value (undefined by default) if for *any* reason it is unable to otherwise resolve the type of the parameter.
- * WARNING!  It is your responsibility to ensure that alt is of the appropriate type/value.
- */
-export declare function Optional(alt?: any): ParameterDecorator;
-/**
- * This is a helper function used by the container to retrieve the @Optional metadata for a specifically indexed constructor parameter
- *
- * @param target  The constructor function of the class (we don't allow @Optional on anything else).
- * @param parameterIndex    The ordinal index of the parameter in the constructor’s parameter list
- * @see Optional
- * @returns an object containing the value provided in the decorator, or undefined if no annotation was present.
- */
-export declare function _getOptionalDefaultAt(target: Function, parameterIndex: number): {
-    value: any;
-};
-/**
- * Placed just before a class method, this method decorator flags a method that should be called after an object has been instantiated by the container, but before it is put into service.
- * The method will be assumed to be synchronous unless the method signature explicitly declares it's return type to be ": Promise<something>"
- * This decorator will throw if placed on a non-method or a static method of a class, or if placed on a method more than once, or if placed on more than one method for a class.
- */
-export declare function PostConstruct(): MethodDecorator;
-/**
- * Placed just before a class method, this decorator identifies a method which should be called when an object is removed from service.
- * If invoked by the container, the container will drop any references it has to the object when the method returns.
- * Note that this decorator is *not* a guarantee (or even an implication) that the decorated method will be called (JavaScript has no mechanism to enforce such a contract).
- * This decorator simply serves as a flag to indicate a method which is intended to clean up resources allocated by the object *which would not otherwise be garbage collected*.
- * You should *not* use this decorator as a general "object finalization" method.  It has very limited scope and purpose.
- * The decorated method must complete normally (no throwing), as "release" is not an abort-able process.
- * This decorator will throw if placed on a non-method or a static method of a class, or if placed on a method more than once, or if placed on more than one method for a class.
- * The @see InvokeReleaseMethod helper function can search for and invoke the @Release decorated method of an object.
- * Also @see Container.releaseSingletons for the intended usage of this decorator.
- * It is intended that after the @Release decorated method of an object is called, that object will not be used again, but this is of course not enforced).
- */
-export declare function Release(): MethodDecorator;

package/lib/esm/index.d.ts

@@ -1,4 +0,0 @@
-export { Binder, SyncFactory, AsyncFactory, BindAs } from './binder.js';
-export { Container } from './container.js';
-export { Inject, Injectable, Optional, PostConstruct, Release } from './decorators.js';
-export { ClassConstructor, InjectableId, InjectionToken, Injector } from './injector.js';

package/lib/esm/injector.d.ts

@@ -1,47 +0,0 @@
-/**
- * This is about as close as we can get in Typescript
- */
-export type AbstractConstructor<T> = Function & {
-    prototype: T;
-};
-/**
- * Standard definition of a constructor.
- */
-export type ClassConstructor<T> = new (...args: any[]) => T;
-/**
- * Allow for implicit typing of constants and interfaces.
- * Inspired by Angular and some colleges at work.
- */
-export declare class InjectionToken<T> {
-    private id;
-    constructor(id: string | symbol);
-    toString(): string;
-}
-/**
- * Universal id that can be bound to a constant, class, or factories.
- */
-export type InjectableId<T> = string | symbol | AbstractConstructor<T> | ClassConstructor<T> | InjectionToken<T>;
-/**
- * Retrieve instances previously bound to the specified InjectableId.
- */
-export interface Injector {
-    /**
-     * Check to see if the existing InjectableId is known (aka has been bound).
-     * Error callbacks may wish to know if a particular InjectableId is available.
-     * Also the Binder's bindXXX calls always overwrite any previous bindings, so you may want to use this as a gate.
-     *
-     * @param id    The id to check for.
-     * @param ascending If true, this will search up the chain of parent containers (if they exist).  Default is false (only checks if the id is bound within this container).
-     */
-    isIdKnown<T>(id: InjectableId<T> | AbstractConstructor<T>, ascending?: boolean): boolean;
-    /**
-     * Return an instance of <T> previously bound to 'id'.
-     *
-     * @throws Error if the InjectableId was never registered, OR if there are unresolved asynchronous dependencies in the dependency tree for 'id'.
-     */
-    get<T>(id: InjectableId<T> | AbstractConstructor<T>): T;
-    /**
-     * awaits the asynchronous resolution of all dependencies in the tree for 'id'.
-     */
-    resolve<T>(id?: InjectableId<T> | AbstractConstructor<T>): Promise<T>;
-}

package/lib/esm/provider.d.ts

@@ -1,37 +0,0 @@
-import { State } from './state.js';
-/**
- * Internally all InjectableIds are mapped to an abstract Provider<T>.
- * A Provider may choose to return a singleton or a new value each time it is queried.
- */
-export declare abstract class Provider<T = any> {
-    protected constructor();
-    /**
-     * If the provider is configured as a singleton, this property will be the state of that singleton.
-     * This value will be defined for resolved/resolving Singletons, null for Singletons that have not yet been queried, and will remain undefined for non-Singleton Providers.
-     * Default value is undefined (e.g. not a Singleton).
-     */
-    protected singleton?: State<T>;
-    /**
-     * This is the workhorse method of the Provider, and is invoked directly or indirectly by both Injector.get and Injector.resolve.
-     * This method returns the current State<T> if it is already known (which it might be for Singleton scenarios).
-     * Otherwise it resolves the State<T>.
-     * IF the Provider<T> is a Singleton, it's State<T> is updated before returning.
-     */
-    abstract provideAsState(): State<T>;
-    /**
-     * Base method to initialize the state of this Provider *if* (and only if) it has been configured as a Singleton.
-     * If this Provider has not been configured as a singleton, this method is essentially a noop that returns undefined.
-     *
-     * @param asyncOnly This default implementation ignores this parameter.
-     * @returns A completion Promise if initialization requires asynchronicity, otherwise the return value is undefined.
-     */
-    resolveIfSingleton(asyncOnly: boolean): Promise<T>;
-    /**
-     * If (and only if) this Provider has been configured as a Singleton, and if it has been (or is being resolved), find and invoke the @Release decorated method (if there is one).
-     * NOTE that if the singleton is actively being resolved when this method is called, this method waits for the resolution to complete and then invokes the @Release decorated method; But in any case this is a synchronous method and returns immediately to it's caller.
-     * Also note that invoking this method does not release or invalidate the Provider;
-     * Rather, it resets a Singleton Provider to a fresh (unresolved/unqueried) state (aka sets this.singleton to null).
-     * It is assumed that the Singleton itself will no longer be used after this method returns.
-     */
-    releaseIfSingleton(): void;
-}

package/lib/esm/state.d.ts

@@ -1,15 +0,0 @@
-/**
- * Internal class that allows us to track the state of a promise (chain).
- */
-export declare class State<T = any> {
-    static MakeState<TState = any>(promise: Promise<TState>, rejected?: unknown, fulfilled?: TState): State<TState>;
-    protected constructor();
-    protected _promise: Promise<T>;
-    get promise(): Promise<T>;
-    protected _pending: boolean;
-    get pending(): boolean;
-    protected _fulfilled: T;
-    get fulfilled(): T;
-    protected _rejected: unknown;
-    get rejected(): unknown;
-}

package/lib/esm/sync-factory-provider.d.ts

@@ -1,21 +0,0 @@
-import { BindableProvider } from './bindable-provider.js';
-import { SyncFactory } from './binder.js';
-import { InjectableId, Injector } from './injector.js';
-import { State } from './state.js';
-/**
- * @inheritDoc
- * This specialization simply invokes it's configured Factory and provides the result.
- */
-export declare class FactoryBasedProvider<T> extends BindableProvider<T, SyncFactory<T>> {
-    constructor(injector: Injector, id: InjectableId<T>, maker: SyncFactory<T>);
-    /**
-     * @inheritDoc
-     * This specialization invokes it's configured Factory and provides the result (or invokes the error handler if necessary).
-     */
-    provideAsState(): State<T>;
-    /**
-     * @inheritDoc
-     * This specialization returns undefined anytime 'asyncOnly' is true (since this Provider is by definition synchronous).
-     */
-    resolveIfSingleton(asyncOnly: boolean): Promise<T>;
-}

package/lib/esm/utils.d.ts

@@ -1,14 +0,0 @@
-/**
- * Returns true if the specified object looks like a JavaScript Error object.
- */
-export declare function isErrorObj(err: any): err is Error;
-/**
- * Returns true if the specified value is "thenable" (aka a Promise).
- */
-export declare function isPromise<T>(value: any): value is Promise<T>;
-/**
- * Simple helper function to find the @Release decorated method of an object (if any), and invoke it.
- * This is primarily an internal method as you probably know the exact method, and should invoke it yourself.
- * async-injection uses this helper to allow Singletons to clean up any non-garbage-collectable resources they may have allocated.
- */
-export declare function InvokeReleaseMethod<T = unknown>(obj: T): boolean;