inversify 6.1.4 → 6.1.5-beta.0

package/amd/container/container_module.d.ts

@@ -1,11 +0,0 @@
-import { interfaces } from '../interfaces/interfaces';
-export declare class ContainerModule implements interfaces.ContainerModule {
-    id: number;
-    registry: interfaces.ContainerModuleCallBack;
-    constructor(registry: interfaces.ContainerModuleCallBack);
-}
-export declare class AsyncContainerModule implements interfaces.AsyncContainerModule {
-    id: number;
-    registry: interfaces.AsyncContainerModuleCallBack;
-    constructor(registry: interfaces.AsyncContainerModuleCallBack);
-}

package/amd/container/container_module.js

@@ -1,21 +0,0 @@
-define(["require", "exports", "../utils/id"], function (require, exports, id_1) {
-    "use strict";
-    Object.defineProperty(exports, "__esModule", { value: true });
-    exports.AsyncContainerModule = exports.ContainerModule = void 0;
-    var ContainerModule = (function () {
-        function ContainerModule(registry) {
-            this.id = (0, id_1.id)();
-            this.registry = registry;
-        }
-        return ContainerModule;
-    }());
-    exports.ContainerModule = ContainerModule;
-    var AsyncContainerModule = (function () {
-        function AsyncContainerModule(registry) {
-            this.id = (0, id_1.id)();
-            this.registry = registry;
-        }
-        return AsyncContainerModule;
-    }());
-    exports.AsyncContainerModule = AsyncContainerModule;
-});

package/amd/container/container_snapshot.d.ts

@@ -1,10 +0,0 @@
-import { interfaces } from '../interfaces/interfaces';
-declare class ContainerSnapshot implements interfaces.ContainerSnapshot {
-    bindings: interfaces.Lookup<interfaces.Binding<unknown>>;
-    activations: interfaces.Lookup<interfaces.BindingActivation<unknown>>;
-    deactivations: interfaces.Lookup<interfaces.BindingDeactivation<unknown>>;
-    middleware: interfaces.Next | null;
-    moduleActivationStore: interfaces.ModuleActivationStore;
-    static of(bindings: interfaces.Lookup<interfaces.Binding<unknown>>, middleware: interfaces.Next | null, activations: interfaces.Lookup<interfaces.BindingActivation<unknown>>, deactivations: interfaces.Lookup<interfaces.BindingDeactivation<unknown>>, moduleActivationStore: interfaces.ModuleActivationStore): ContainerSnapshot;
-}
-export { ContainerSnapshot };

package/amd/container/container_snapshot.js

@@ -1,20 +0,0 @@
-define(["require", "exports"], function (require, exports) {
-    "use strict";
-    Object.defineProperty(exports, "__esModule", { value: true });
-    exports.ContainerSnapshot = void 0;
-    var ContainerSnapshot = (function () {
-        function ContainerSnapshot() {
-        }
-        ContainerSnapshot.of = function (bindings, middleware, activations, deactivations, moduleActivationStore) {
-            var snapshot = new ContainerSnapshot();
-            snapshot.bindings = bindings;
-            snapshot.middleware = middleware;
-            snapshot.deactivations = deactivations;
-            snapshot.activations = activations;
-            snapshot.moduleActivationStore = moduleActivationStore;
-            return snapshot;
-        };
-        return ContainerSnapshot;
-    }());
-    exports.ContainerSnapshot = ContainerSnapshot;
-});

package/amd/container/lookup.d.ts

@@ -1,17 +0,0 @@
-import { interfaces } from '../interfaces/interfaces';
-declare class Lookup<T> implements interfaces.Lookup<T> {
-    private readonly _map;
-    constructor();
-    getMap(): Map<interfaces.ServiceIdentifier<unknown>, T[]>;
-    add(serviceIdentifier: interfaces.ServiceIdentifier, value: T): void;
-    get(serviceIdentifier: interfaces.ServiceIdentifier): T[];
-    remove(serviceIdentifier: interfaces.ServiceIdentifier): void;
-    removeIntersection(lookup: interfaces.Lookup<T>): void;
-    removeByCondition(condition: (item: T) => boolean): T[];
-    hasKey(serviceIdentifier: interfaces.ServiceIdentifier): boolean;
-    clone(): interfaces.Lookup<T>;
-    traverse(func: (key: interfaces.ServiceIdentifier, value: T[]) => void): void;
-    private _checkNonNulish;
-    private _setValue;
-}
-export { Lookup };

package/amd/container/lookup.js

@@ -1,132 +0,0 @@
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-define(["require", "exports", "../constants/error_msgs", "../utils/clonable"], function (require, exports, ERROR_MSGS, clonable_1) {
-    "use strict";
-    Object.defineProperty(exports, "__esModule", { value: true });
-    exports.Lookup = void 0;
-    ERROR_MSGS = __importStar(ERROR_MSGS);
-    var Lookup = (function () {
-        function Lookup() {
-            this._map = new Map();
-        }
-        Lookup.prototype.getMap = function () {
-            return this._map;
-        };
-        Lookup.prototype.add = function (serviceIdentifier, value) {
-            this._checkNonNulish(serviceIdentifier);
-            if (value === null || value === undefined) {
-                throw new Error(ERROR_MSGS.NULL_ARGUMENT);
-            }
-            var entry = this._map.get(serviceIdentifier);
-            if (entry !== undefined) {
-                entry.push(value);
-            }
-            else {
-                this._map.set(serviceIdentifier, [value]);
-            }
-        };
-        Lookup.prototype.get = function (serviceIdentifier) {
-            this._checkNonNulish(serviceIdentifier);
-            var entry = this._map.get(serviceIdentifier);
-            if (entry !== undefined) {
-                return entry;
-            }
-            else {
-                throw new Error(ERROR_MSGS.KEY_NOT_FOUND);
-            }
-        };
-        Lookup.prototype.remove = function (serviceIdentifier) {
-            this._checkNonNulish(serviceIdentifier);
-            if (!this._map.delete(serviceIdentifier)) {
-                throw new Error(ERROR_MSGS.KEY_NOT_FOUND);
-            }
-        };
-        Lookup.prototype.removeIntersection = function (lookup) {
-            var _this = this;
-            this.traverse(function (serviceIdentifier, value) {
-                var lookupActivations = lookup.hasKey(serviceIdentifier)
-                    ? lookup.get(serviceIdentifier)
-                    : undefined;
-                if (lookupActivations !== undefined) {
-                    var filteredValues = value.filter(function (lookupValue) {
-                        return !lookupActivations.some(function (moduleActivation) { return lookupValue === moduleActivation; });
-                    });
-                    _this._setValue(serviceIdentifier, filteredValues);
-                }
-            });
-        };
-        Lookup.prototype.removeByCondition = function (condition) {
-            var _this = this;
-            var removals = [];
-            this._map.forEach(function (entries, key) {
-                var updatedEntries = [];
-                for (var _i = 0, entries_1 = entries; _i < entries_1.length; _i++) {
-                    var entry = entries_1[_i];
-                    var remove = condition(entry);
-                    if (remove) {
-                        removals.push(entry);
-                    }
-                    else {
-                        updatedEntries.push(entry);
-                    }
-                }
-                _this._setValue(key, updatedEntries);
-            });
-            return removals;
-        };
-        Lookup.prototype.hasKey = function (serviceIdentifier) {
-            this._checkNonNulish(serviceIdentifier);
-            return this._map.has(serviceIdentifier);
-        };
-        Lookup.prototype.clone = function () {
-            var copy = new Lookup();
-            this._map.forEach(function (value, key) {
-                value.forEach(function (b) {
-                    copy.add(key, (0, clonable_1.isClonable)(b) ? b.clone() : b);
-                });
-            });
-            return copy;
-        };
-        Lookup.prototype.traverse = function (func) {
-            this._map.forEach(function (value, key) {
-                func(key, value);
-            });
-        };
-        Lookup.prototype._checkNonNulish = function (value) {
-            if (value == null) {
-                throw new Error(ERROR_MSGS.NULL_ARGUMENT);
-            }
-        };
-        Lookup.prototype._setValue = function (serviceIdentifier, value) {
-            if (value.length > 0) {
-                this._map.set(serviceIdentifier, value);
-            }
-            else {
-                this._map.delete(serviceIdentifier);
-            }
-        };
-        return Lookup;
-    }());
-    exports.Lookup = Lookup;
-});

package/amd/container/module_activation_store.d.ts

@@ -1,10 +0,0 @@
-import { interfaces } from '../interfaces/interfaces';
-export declare class ModuleActivationStore implements interfaces.ModuleActivationStore {
-    private readonly _map;
-    remove(moduleId: number): interfaces.ModuleActivationHandlers;
-    addDeactivation(moduleId: number, serviceIdentifier: interfaces.ServiceIdentifier<unknown>, onDeactivation: interfaces.BindingDeactivation<unknown>): void;
-    addActivation(moduleId: number, serviceIdentifier: interfaces.ServiceIdentifier<unknown>, onActivation: interfaces.BindingActivation<unknown>): void;
-    clone(): interfaces.ModuleActivationStore;
-    private _getModuleActivationHandlers;
-    private _getEmptyHandlersStore;
-}

package/amd/container/module_activation_store.js

@@ -1,51 +0,0 @@
-define(["require", "exports", "./lookup"], function (require, exports, lookup_1) {
-    "use strict";
-    Object.defineProperty(exports, "__esModule", { value: true });
-    exports.ModuleActivationStore = void 0;
-    var ModuleActivationStore = (function () {
-        function ModuleActivationStore() {
-            this._map = new Map();
-        }
-        ModuleActivationStore.prototype.remove = function (moduleId) {
-            var handlers = this._map.get(moduleId);
-            if (handlers === undefined) {
-                return this._getEmptyHandlersStore();
-            }
-            this._map.delete(moduleId);
-            return handlers;
-        };
-        ModuleActivationStore.prototype.addDeactivation = function (moduleId, serviceIdentifier, onDeactivation) {
-            this._getModuleActivationHandlers(moduleId).onDeactivations.add(serviceIdentifier, onDeactivation);
-        };
-        ModuleActivationStore.prototype.addActivation = function (moduleId, serviceIdentifier, onActivation) {
-            this._getModuleActivationHandlers(moduleId).onActivations.add(serviceIdentifier, onActivation);
-        };
-        ModuleActivationStore.prototype.clone = function () {
-            var clone = new ModuleActivationStore();
-            this._map.forEach(function (handlersStore, moduleId) {
-                clone._map.set(moduleId, {
-                    onActivations: handlersStore.onActivations.clone(),
-                    onDeactivations: handlersStore.onDeactivations.clone(),
-                });
-            });
-            return clone;
-        };
-        ModuleActivationStore.prototype._getModuleActivationHandlers = function (moduleId) {
-            var moduleActivationHandlers = this._map.get(moduleId);
-            if (moduleActivationHandlers === undefined) {
-                moduleActivationHandlers = this._getEmptyHandlersStore();
-                this._map.set(moduleId, moduleActivationHandlers);
-            }
-            return moduleActivationHandlers;
-        };
-        ModuleActivationStore.prototype._getEmptyHandlersStore = function () {
-            var handlersStore = {
-                onActivations: new lookup_1.Lookup(),
-                onDeactivations: new lookup_1.Lookup(),
-            };
-            return handlersStore;
-        };
-        return ModuleActivationStore;
-    }());
-    exports.ModuleActivationStore = ModuleActivationStore;
-});

package/amd/interfaces/interfaces.d.ts

@@ -1,269 +0,0 @@
-import { Newable as CommonNewable, ServiceIdentifier as CommonServiceIdentifier } from '@inversifyjs/common';
-import { LegacyTarget } from '@inversifyjs/core';
-import { FactoryType } from '../utils/factory_type';
-declare namespace interfaces {
-    export type DynamicValue<T> = (context: interfaces.Context) => T | Promise<T>;
-    export type ContainerResolution<T> = T | Promise<T> | (T | Promise<T>)[];
-    type AsyncCallback<TCallback> = TCallback extends (...args: infer TArgs) => infer TResult ? (...args: TArgs) => Promise<TResult> : never;
-    export type BindingScope = 'Singleton' | 'Transient' | 'Request';
-    export type BindingType = 'ConstantValue' | 'Constructor' | 'DynamicValue' | 'Factory' | 'Function' | 'Instance' | 'Invalid' | 'Provider';
-    export type TargetType = 'ConstructorArgument' | 'ClassProperty' | 'Variable';
-    export interface BindingScopeEnum {
-        Request: interfaces.BindingScope;
-        Singleton: interfaces.BindingScope;
-        Transient: interfaces.BindingScope;
-    }
-    export interface BindingTypeEnum {
-        ConstantValue: interfaces.BindingType;
-        Constructor: interfaces.BindingType;
-        DynamicValue: interfaces.BindingType;
-        Factory: interfaces.BindingType;
-        Function: interfaces.BindingType;
-        Instance: interfaces.BindingType;
-        Invalid: interfaces.BindingType;
-        Provider: interfaces.BindingType;
-    }
-    export interface TargetTypeEnum {
-        ConstructorArgument: interfaces.TargetType;
-        ClassProperty: interfaces.TargetType;
-        Variable: interfaces.TargetType;
-    }
-    export type Newable<TInstance = unknown> = CommonNewable<TInstance>;
-    export type Instance<T> = T & Record<string, () => void>;
-    export interface Abstract<T> {
-        prototype: T;
-    }
-    export type ServiceIdentifier<T = unknown> = CommonServiceIdentifier<T>;
-    export interface Clonable<T> {
-        clone(): T;
-    }
-    export type BindingActivation<T = unknown> = (context: interfaces.Context, injectable: T) => T | Promise<T>;
-    export type BindingDeactivation<T = unknown> = (injectable: T) => void | Promise<void>;
-    export interface Binding<TActivated = unknown> extends Clonable<Binding<TActivated>> {
-        id: number;
-        moduleId: ContainerModuleBase['id'];
-        activated: boolean;
-        serviceIdentifier: ServiceIdentifier<TActivated>;
-        constraint: ConstraintFunction;
-        dynamicValue: DynamicValue<TActivated> | null;
-        scope: BindingScope;
-        type: BindingType;
-        implementationType: Newable<TActivated> | TActivated | null;
-        factory: FactoryCreator<unknown> | null;
-        provider: ProviderCreator<unknown> | null;
-        onActivation: BindingActivation<TActivated> | null;
-        onDeactivation: BindingDeactivation<TActivated> | null;
-        cache: null | TActivated | Promise<TActivated>;
-    }
-    export type SimpleFactory<T, U extends unknown[] = unknown[]> = (...args: U) => T;
-    export type MultiFactory<T, U extends unknown[] = unknown[], V extends unknown[] = unknown[]> = (...args: U) => SimpleFactory<T, V>;
-    export type Factory<T, U extends unknown[] = unknown[], V extends unknown[] = unknown[]> = SimpleFactory<T, U> | MultiFactory<T, U, V>;
-    export type FactoryCreator<T, U extends unknown[] = unknown[], V extends unknown[] = unknown[]> = (context: Context) => Factory<T, U, V>;
-    export type AutoNamedFactory<T> = SimpleFactory<T, [string]>;
-    export type AutoFactory<T> = SimpleFactory<T, []>;
-    export type FactoryTypeFunction<T = unknown> = (context: interfaces.Context) => T | Promise<T>;
-    export interface FactoryDetails {
-        factoryType: FactoryType;
-        factory: FactoryTypeFunction | null;
-    }
-    export type Provider<T> = (...args: any[]) => ((...args: any[]) => Promise<T>) | Promise<T>;
-    export type ProviderCreator<T> = (context: Context) => Provider<T>;
-    export interface NextArgs<T = unknown> {
-        avoidConstraints: boolean;
-        contextInterceptor: (contexts: Context) => Context;
-        isMultiInject: boolean;
-        targetType: TargetType;
-        serviceIdentifier: interfaces.ServiceIdentifier<T>;
-        key?: string | number | symbol | undefined;
-        value?: unknown;
-    }
-    export type Next = (args: NextArgs) => unknown | unknown[];
-    export type Middleware = (next: Next) => Next;
-    export type ContextInterceptor = (context: interfaces.Context) => interfaces.Context;
-    export interface Context {
-        id: number;
-        container: Container;
-        plan: Plan;
-        currentRequest: Request;
-        addPlan(plan: Plan): void;
-        setCurrentRequest(request: Request): void;
-    }
-    export type MetadataOrMetadataArray = Metadata | Metadata[];
-    export interface Metadata<TValue = unknown> {
-        key: string | number | symbol;
-        value: TValue;
-    }
-    export interface Plan {
-        parentContext: Context;
-        rootRequest: Request;
-    }
-    export interface QueryableString {
-        startsWith(searchString: string): boolean;
-        endsWith(searchString: string): boolean;
-        contains(searchString: string): boolean;
-        equals(compareString: string): boolean;
-        value(): string;
-    }
-    export type ResolveRequestHandler = (request: interfaces.Request) => unknown;
-    export type RequestScope = Map<unknown, unknown>;
-    export interface Request {
-        id: number;
-        serviceIdentifier: ServiceIdentifier;
-        parentContext: Context;
-        parentRequest: Request | null;
-        childRequests: Request[];
-        target: Target;
-        bindings: Binding<unknown>[];
-        requestScope: RequestScope | null;
-        addChildRequest(serviceIdentifier: ServiceIdentifier, bindings: Binding<unknown> | Binding<unknown>[], target: Target): Request;
-    }
-    export type Target = LegacyTarget;
-    export interface ContainerOptions {
-        autoBindInjectable?: boolean;
-        defaultScope?: BindingScope | undefined;
-        skipBaseClassChecks?: boolean;
-    }
-    export interface Container {
-        id: number;
-        parent: Container | null;
-        options: ContainerOptions;
-        bind<T>(serviceIdentifier: ServiceIdentifier<T>): BindingToSyntax<T>;
-        rebind<T>(serviceIdentifier: interfaces.ServiceIdentifier<T>): interfaces.BindingToSyntax<T>;
-        rebindAsync<T>(serviceIdentifier: interfaces.ServiceIdentifier<T>): Promise<interfaces.BindingToSyntax<T>>;
-        unbind(serviceIdentifier: ServiceIdentifier): void;
-        unbindAsync(serviceIdentifier: interfaces.ServiceIdentifier): Promise<void>;
-        unbindAll(): void;
-        unbindAllAsync(): Promise<void>;
-        isBound(serviceIdentifier: ServiceIdentifier): boolean;
-        isCurrentBound<T>(serviceIdentifier: ServiceIdentifier<T>): boolean;
-        isBoundNamed(serviceIdentifier: ServiceIdentifier, named: string | number | symbol): boolean;
-        isBoundTagged(serviceIdentifier: ServiceIdentifier, key: string | number | symbol, value: unknown): boolean;
-        get<T>(serviceIdentifier: ServiceIdentifier<T>): T;
-        getNamed<T>(serviceIdentifier: ServiceIdentifier<T>, named: string | number | symbol): T;
-        getTagged<T>(serviceIdentifier: ServiceIdentifier<T>, key: string | number | symbol, value: unknown): T;
-        getAll<T>(serviceIdentifier: ServiceIdentifier<T>): T[];
-        getAllTagged<T>(serviceIdentifier: ServiceIdentifier<T>, key: string | number | symbol, value: unknown): T[];
-        getAllNamed<T>(serviceIdentifier: ServiceIdentifier<T>, named: string | number | symbol): T[];
-        getAsync<T>(serviceIdentifier: ServiceIdentifier<T>): Promise<T>;
-        getNamedAsync<T>(serviceIdentifier: ServiceIdentifier<T>, named: string | number | symbol): Promise<T>;
-        getTaggedAsync<T>(serviceIdentifier: ServiceIdentifier<T>, key: string | number | symbol, value: unknown): Promise<T>;
-        getAllAsync<T>(serviceIdentifier: ServiceIdentifier<T>): Promise<T[]>;
-        getAllTaggedAsync<T>(serviceIdentifier: ServiceIdentifier<T>, key: string | number | symbol, value: unknown): Promise<T[]>;
-        getAllNamedAsync<T>(serviceIdentifier: ServiceIdentifier<T>, named: string | number | symbol): Promise<T[]>;
-        onActivation<T>(serviceIdentifier: ServiceIdentifier<T>, onActivation: BindingActivation<T>): void;
-        onDeactivation<T>(serviceIdentifier: ServiceIdentifier<T>, onDeactivation: BindingDeactivation<T>): void;
-        resolve<T>(constructorFunction: interfaces.Newable<T>): T;
-        load(...modules: ContainerModule[]): void;
-        loadAsync(...modules: AsyncContainerModule[]): Promise<void>;
-        unload(...modules: ContainerModuleBase[]): void;
-        unloadAsync(...modules: ContainerModuleBase[]): Promise<void>;
-        applyCustomMetadataReader(metadataReader: MetadataReader): void;
-        applyMiddleware(...middleware: Middleware[]): void;
-        snapshot(): void;
-        restore(): void;
-        createChild(): Container;
-    }
-    export type Bind = <T = unknown>(serviceIdentifier: ServiceIdentifier<T>) => BindingToSyntax<T>;
-    export type Rebind = <T = unknown>(serviceIdentifier: ServiceIdentifier<T>) => BindingToSyntax<T>;
-    export type Unbind = <T = unknown>(serviceIdentifier: ServiceIdentifier<T>) => void;
-    export type UnbindAsync = <T = unknown>(serviceIdentifier: ServiceIdentifier<T>) => Promise<void>;
-    export type IsBound = <T = unknown>(serviceIdentifier: ServiceIdentifier<T>) => boolean;
-    export interface ContainerModuleBase {
-        id: number;
-    }
-    export interface ContainerModule extends ContainerModuleBase {
-        registry: ContainerModuleCallBack;
-    }
-    export interface AsyncContainerModule extends ContainerModuleBase {
-        registry: AsyncContainerModuleCallBack;
-    }
-    export interface ModuleActivationHandlers {
-        onActivations: Lookup<BindingActivation<unknown>>;
-        onDeactivations: Lookup<BindingDeactivation<unknown>>;
-    }
-    export interface ModuleActivationStore extends Clonable<ModuleActivationStore> {
-        addDeactivation(moduleId: ContainerModuleBase['id'], serviceIdentifier: ServiceIdentifier<unknown>, onDeactivation: interfaces.BindingDeactivation<unknown>): void;
-        addActivation(moduleId: ContainerModuleBase['id'], serviceIdentifier: ServiceIdentifier<unknown>, onActivation: interfaces.BindingActivation<unknown>): void;
-        remove(moduleId: ContainerModuleBase['id']): ModuleActivationHandlers;
-    }
-    export type ContainerModuleCallBack = (bind: interfaces.Bind, unbind: interfaces.Unbind, isBound: interfaces.IsBound, rebind: interfaces.Rebind, unbindAsync: interfaces.UnbindAsync, onActivation: interfaces.Container['onActivation'], onDeactivation: interfaces.Container['onDeactivation']) => void;
-    export type AsyncContainerModuleCallBack = AsyncCallback<ContainerModuleCallBack>;
-    export interface ContainerSnapshot {
-        bindings: Lookup<Binding<unknown>>;
-        activations: Lookup<BindingActivation<unknown>>;
-        deactivations: Lookup<BindingDeactivation<unknown>>;
-        middleware: Next | null;
-        moduleActivationStore: interfaces.ModuleActivationStore;
-    }
-    export interface Lookup<T> extends Clonable<Lookup<T>> {
-        add(serviceIdentifier: ServiceIdentifier, value: T): void;
-        getMap(): Map<interfaces.ServiceIdentifier, T[]>;
-        get(serviceIdentifier: ServiceIdentifier): T[];
-        remove(serviceIdentifier: interfaces.ServiceIdentifier): void;
-        removeByCondition(condition: (item: T) => boolean): T[];
-        removeIntersection(lookup: interfaces.Lookup<T>): void;
-        hasKey(serviceIdentifier: ServiceIdentifier): boolean;
-        clone(): Lookup<T>;
-        traverse(func: (key: interfaces.ServiceIdentifier, value: T[]) => void): void;
-    }
-    export interface BindingOnSyntax<T> {
-        onActivation(fn: (context: Context, injectable: T) => T | Promise<T>): BindingWhenSyntax<T>;
-        onDeactivation(fn: (injectable: T) => void | Promise<void>): BindingWhenSyntax<T>;
-    }
-    export interface BindingWhenSyntax<T> {
-        when(constraint: (request: Request) => boolean): BindingOnSyntax<T>;
-        whenTargetNamed(name: string | number | symbol): BindingOnSyntax<T>;
-        whenTargetIsDefault(): BindingOnSyntax<T>;
-        whenTargetTagged(tag: string | number | symbol, value: unknown): BindingOnSyntax<T>;
-        whenInjectedInto(parent: NewableFunction | string): BindingOnSyntax<T>;
-        whenParentNamed(name: string | number | symbol): BindingOnSyntax<T>;
-        whenParentTagged(tag: string | number | symbol, value: unknown): BindingOnSyntax<T>;
-        whenAnyAncestorIs(ancestor: NewableFunction | string): BindingOnSyntax<T>;
-        whenNoAncestorIs(ancestor: NewableFunction | string): BindingOnSyntax<T>;
-        whenAnyAncestorNamed(name: string | number | symbol): BindingOnSyntax<T>;
-        whenAnyAncestorTagged(tag: string | number | symbol, value: unknown): BindingOnSyntax<T>;
-        whenNoAncestorNamed(name: string | number | symbol): BindingOnSyntax<T>;
-        whenNoAncestorTagged(tag: string | number | symbol, value: unknown): BindingOnSyntax<T>;
-        whenAnyAncestorMatches(constraint: (request: Request) => boolean): BindingOnSyntax<T>;
-        whenNoAncestorMatches(constraint: (request: Request) => boolean): BindingOnSyntax<T>;
-    }
-    export interface BindingWhenOnSyntax<T> extends BindingWhenSyntax<T>, BindingOnSyntax<T> {
-    }
-    export interface BindingInSyntax<T> {
-        inSingletonScope(): BindingWhenOnSyntax<T>;
-        inTransientScope(): BindingWhenOnSyntax<T>;
-        inRequestScope(): BindingWhenOnSyntax<T>;
-    }
-    export interface BindingInWhenOnSyntax<T> extends BindingInSyntax<T>, BindingWhenOnSyntax<T> {
-    }
-    export interface BindingToSyntax<T> {
-        to(constructor: Newable<T>): BindingInWhenOnSyntax<T>;
-        toSelf(): BindingInWhenOnSyntax<T>;
-        toConstantValue(value: T): BindingWhenOnSyntax<T>;
-        toDynamicValue(func: DynamicValue<T>): BindingInWhenOnSyntax<T>;
-        toConstructor<T2>(constructor: Newable<T2>): BindingWhenOnSyntax<T>;
-        toFactory<T2, T3 extends unknown[] = unknown[], T4 extends unknown[] = unknown[]>(factory: FactoryCreator<T2, T3, T4>): BindingWhenOnSyntax<T>;
-        toFunction(func: T): BindingWhenOnSyntax<T>;
-        toAutoFactory<T2>(serviceIdentifier: ServiceIdentifier<T2>): BindingWhenOnSyntax<T>;
-        toAutoNamedFactory<T2>(serviceIdentifier: ServiceIdentifier<T2>): BindingWhenOnSyntax<T>;
-        toProvider<T2>(provider: ProviderCreator<T2>): BindingWhenOnSyntax<T>;
-        toService(service: ServiceIdentifier<T>): void;
-    }
-    export interface ConstraintFunction {
-        (request: Request | null): boolean;
-        metaData?: Metadata;
-    }
-    export interface MetadataReader {
-        getConstructorMetadata(constructorFunc: NewableFunction): ConstructorMetadata;
-        getPropertiesMetadata(constructorFunc: NewableFunction): MetadataMap;
-    }
-    export interface MetadataMap {
-        [propertyNameOrArgumentIndex: string | symbol]: Metadata[];
-    }
-    export interface ConstructorMetadata {
-        compilerGeneratedMetadata: NewableFunction[] | undefined;
-        userGeneratedMetadata: MetadataMap;
-    }
-    export {};
-}
-export type { interfaces };

package/amd/interfaces/interfaces.js

@@ -1,4 +0,0 @@
-define(["require", "exports"], function (require, exports) {
-    "use strict";
-    Object.defineProperty(exports, "__esModule", { value: true });
-});

package/amd/inversify.d.ts

@@ -1,24 +0,0 @@
-import * as keys from './constants/metadata_keys';
-export { LazyServiceIdentifier } from '@inversifyjs/common';
-export declare const METADATA_KEY: typeof keys;
-export { Container } from './container/container';
-export { BindingScopeEnum, BindingTypeEnum, TargetTypeEnum, } from './constants/literal_types';
-export { AsyncContainerModule, ContainerModule, } from './container/container_module';
-export { createTaggedDecorator } from './annotation/decorator_utils';
-export { injectable } from './annotation/injectable';
-export { tagged } from './annotation/tagged';
-export { named } from './annotation/named';
-export { inject } from './annotation/inject';
-export { optional } from './annotation/optional';
-export { unmanaged } from './annotation/unmanaged';
-export { multiInject } from './annotation/multi_inject';
-export { targetName } from './annotation/target_name';
-export { postConstruct } from './annotation/post_construct';
-export { preDestroy } from './annotation/pre_destroy';
-export { MetadataReader } from './planning/metadata_reader';
-export { id } from './utils/id';
-export type { interfaces } from './interfaces/interfaces';
-export { decorate } from './annotation/decorator_utils';
-export { traverseAncerstors, taggedConstraint, namedConstraint, typeConstraint, } from './syntax/constraint_helpers';
-export { getServiceIdentifierAsString } from './utils/serialization';
-export { multiBindToService } from './utils/binding_utils';

package/amd/inversify.js

@@ -1,57 +0,0 @@
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-define(["require", "exports", "./constants/metadata_keys", "@inversifyjs/common", "./container/container", "./constants/literal_types", "./container/container_module", "./annotation/decorator_utils", "./annotation/injectable", "./annotation/tagged", "./annotation/named", "./annotation/inject", "./annotation/optional", "./annotation/unmanaged", "./annotation/multi_inject", "./annotation/target_name", "./annotation/post_construct", "./annotation/pre_destroy", "./planning/metadata_reader", "./utils/id", "./annotation/decorator_utils", "./syntax/constraint_helpers", "./utils/serialization", "./utils/binding_utils"], function (require, exports, keys, common_1, container_1, literal_types_1, container_module_1, decorator_utils_1, injectable_1, tagged_1, named_1, inject_1, optional_1, unmanaged_1, multi_inject_1, target_name_1, post_construct_1, pre_destroy_1, metadata_reader_1, id_1, decorator_utils_2, constraint_helpers_1, serialization_1, binding_utils_1) {
-    "use strict";
-    Object.defineProperty(exports, "__esModule", { value: true });
-    exports.multiBindToService = exports.getServiceIdentifierAsString = exports.typeConstraint = exports.namedConstraint = exports.taggedConstraint = exports.traverseAncerstors = exports.decorate = exports.id = exports.MetadataReader = exports.preDestroy = exports.postConstruct = exports.targetName = exports.multiInject = exports.unmanaged = exports.optional = exports.inject = exports.named = exports.tagged = exports.injectable = exports.createTaggedDecorator = exports.ContainerModule = exports.AsyncContainerModule = exports.TargetTypeEnum = exports.BindingTypeEnum = exports.BindingScopeEnum = exports.Container = exports.METADATA_KEY = exports.LazyServiceIdentifier = void 0;
-    keys = __importStar(keys);
-    Object.defineProperty(exports, "LazyServiceIdentifier", { enumerable: true, get: function () { return common_1.LazyServiceIdentifier; } });
-    exports.METADATA_KEY = keys;
-    Object.defineProperty(exports, "Container", { enumerable: true, get: function () { return container_1.Container; } });
-    Object.defineProperty(exports, "BindingScopeEnum", { enumerable: true, get: function () { return literal_types_1.BindingScopeEnum; } });
-    Object.defineProperty(exports, "BindingTypeEnum", { enumerable: true, get: function () { return literal_types_1.BindingTypeEnum; } });
-    Object.defineProperty(exports, "TargetTypeEnum", { enumerable: true, get: function () { return literal_types_1.TargetTypeEnum; } });
-    Object.defineProperty(exports, "AsyncContainerModule", { enumerable: true, get: function () { return container_module_1.AsyncContainerModule; } });
-    Object.defineProperty(exports, "ContainerModule", { enumerable: true, get: function () { return container_module_1.ContainerModule; } });
-    Object.defineProperty(exports, "createTaggedDecorator", { enumerable: true, get: function () { return decorator_utils_1.createTaggedDecorator; } });
-    Object.defineProperty(exports, "injectable", { enumerable: true, get: function () { return injectable_1.injectable; } });
-    Object.defineProperty(exports, "tagged", { enumerable: true, get: function () { return tagged_1.tagged; } });
-    Object.defineProperty(exports, "named", { enumerable: true, get: function () { return named_1.named; } });
-    Object.defineProperty(exports, "inject", { enumerable: true, get: function () { return inject_1.inject; } });
-    Object.defineProperty(exports, "optional", { enumerable: true, get: function () { return optional_1.optional; } });
-    Object.defineProperty(exports, "unmanaged", { enumerable: true, get: function () { return unmanaged_1.unmanaged; } });
-    Object.defineProperty(exports, "multiInject", { enumerable: true, get: function () { return multi_inject_1.multiInject; } });
-    Object.defineProperty(exports, "targetName", { enumerable: true, get: function () { return target_name_1.targetName; } });
-    Object.defineProperty(exports, "postConstruct", { enumerable: true, get: function () { return post_construct_1.postConstruct; } });
-    Object.defineProperty(exports, "preDestroy", { enumerable: true, get: function () { return pre_destroy_1.preDestroy; } });
-    Object.defineProperty(exports, "MetadataReader", { enumerable: true, get: function () { return metadata_reader_1.MetadataReader; } });
-    Object.defineProperty(exports, "id", { enumerable: true, get: function () { return id_1.id; } });
-    Object.defineProperty(exports, "decorate", { enumerable: true, get: function () { return decorator_utils_2.decorate; } });
-    Object.defineProperty(exports, "traverseAncerstors", { enumerable: true, get: function () { return constraint_helpers_1.traverseAncerstors; } });
-    Object.defineProperty(exports, "taggedConstraint", { enumerable: true, get: function () { return constraint_helpers_1.taggedConstraint; } });
-    Object.defineProperty(exports, "namedConstraint", { enumerable: true, get: function () { return constraint_helpers_1.namedConstraint; } });
-    Object.defineProperty(exports, "typeConstraint", { enumerable: true, get: function () { return constraint_helpers_1.typeConstraint; } });
-    Object.defineProperty(exports, "getServiceIdentifierAsString", { enumerable: true, get: function () { return serialization_1.getServiceIdentifierAsString; } });
-    Object.defineProperty(exports, "multiBindToService", { enumerable: true, get: function () { return binding_utils_1.multiBindToService; } });
-});

package/amd/planning/context.d.ts

@@ -1,11 +0,0 @@
-import { interfaces } from '../interfaces/interfaces';
-declare class Context implements interfaces.Context {
-    id: number;
-    container: interfaces.Container;
-    plan: interfaces.Plan;
-    currentRequest: interfaces.Request;
-    constructor(container: interfaces.Container);
-    addPlan(plan: interfaces.Plan): void;
-    setCurrentRequest(currentRequest: interfaces.Request): void;
-}
-export { Context };