@expressots/core 2.16.2 → 3.0.0-beta.1

package/lib/cjs/di/annotation/named.js

@@ -0,0 +1,34 @@
+"use strict";
+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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.named = named;
+const METADATA_KEY = __importStar(require("../constants/metadata_keys"));
+const metadata_1 = require("../planning/metadata");
+const decorator_utils_1 = require("./decorator_utils");
+// Used to add named metadata which is used to resolve name-based contextual bindings.
+// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+function named(name) {
+    return (0, decorator_utils_1.createTaggedDecorator)(new metadata_1.Metadata(METADATA_KEY.NAMED_TAG, name));
+}

package/lib/cjs/di/annotation/optional.js

@@ -0,0 +1,32 @@
+"use strict";
+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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.optional = optional;
+const METADATA_KEY = __importStar(require("../constants/metadata_keys"));
+const metadata_1 = require("../planning/metadata");
+const decorator_utils_1 = require("./decorator_utils");
+function optional() {
+    return (0, decorator_utils_1.createTaggedDecorator)(new metadata_1.Metadata(METADATA_KEY.OPTIONAL_TAG, true));
+}

package/lib/cjs/di/annotation/post_construct.js

@@ -0,0 +1,31 @@
+"use strict";
+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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.postConstruct = void 0;
+const ERRORS_MSGS = __importStar(require("../constants/error_msgs"));
+const METADATA_KEY = __importStar(require("../constants/metadata_keys"));
+const property_event_decorator_1 = require("./property_event_decorator");
+const postConstruct = (0, property_event_decorator_1.propertyEventDecorator)(METADATA_KEY.POST_CONSTRUCT, ERRORS_MSGS.MULTIPLE_POST_CONSTRUCT_METHODS);
+exports.postConstruct = postConstruct;

package/lib/cjs/di/annotation/pre_destroy.js

@@ -0,0 +1,31 @@
+"use strict";
+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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.preDestroy = void 0;
+const ERRORS_MSGS = __importStar(require("../constants/error_msgs"));
+const METADATA_KEY = __importStar(require("../constants/metadata_keys"));
+const property_event_decorator_1 = require("./property_event_decorator");
+const preDestroy = (0, property_event_decorator_1.propertyEventDecorator)(METADATA_KEY.PRE_DESTROY, ERRORS_MSGS.MULTIPLE_PRE_DESTROY_METHODS);
+exports.preDestroy = preDestroy;

package/lib/cjs/di/annotation/property_event_decorator.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.propertyEventDecorator = propertyEventDecorator;
+const metadata_1 = require("../planning/metadata");
+function propertyEventDecorator(eventKey, errorMessage) {
+    return () => {
+        return (target, propertyKey) => {
+            const metadata = new metadata_1.Metadata(eventKey, propertyKey);
+            if (Reflect.hasOwnMetadata(eventKey, target.constructor)) {
+                throw new Error(errorMessage);
+            }
+            Reflect.defineMetadata(eventKey, metadata, target.constructor);
+        };
+    };
+}

package/lib/cjs/di/annotation/tagged.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tagged = tagged;
+const metadata_1 = require("../planning/metadata");
+const decorator_utils_1 = require("./decorator_utils");
+// Used to add custom metadata which is used to resolve metadata-based contextual bindings.
+function tagged(metadataKey, metadataValue) {
+    return (0, decorator_utils_1.createTaggedDecorator)(new metadata_1.Metadata(metadataKey, metadataValue));
+}

package/lib/cjs/di/annotation/target_name.js

@@ -0,0 +1,35 @@
+"use strict";
+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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.targetName = targetName;
+const METADATA_KEY = __importStar(require("../constants/metadata_keys"));
+const metadata_1 = require("../planning/metadata");
+const decorator_utils_1 = require("./decorator_utils");
+function targetName(name) {
+    return function (target, targetKey, index) {
+        const metadata = new metadata_1.Metadata(METADATA_KEY.NAME_TAG, name);
+        (0, decorator_utils_1.tagParameter)(target, targetKey, index, metadata);
+    };
+}

package/lib/cjs/di/annotation/unmanaged.js

@@ -0,0 +1,35 @@
+"use strict";
+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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unmanaged = unmanaged;
+const METADATA_KEY = __importStar(require("../constants/metadata_keys"));
+const metadata_1 = require("../planning/metadata");
+const decorator_utils_1 = require("./decorator_utils");
+function unmanaged() {
+    return function (target, targetKey, index) {
+        const metadata = new metadata_1.Metadata(METADATA_KEY.UNMANAGED_TAG, true);
+        (0, decorator_utils_1.tagParameter)(target, targetKey, index, metadata);
+    };
+}

package/lib/cjs/di/binding-decorator/constants.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.METADATA_KEY = void 0;
+const METADATA_KEY = {
+    provide: "inversify-binding-decorators:provide",
+};
+exports.METADATA_KEY = METADATA_KEY;

package/lib/cjs/di/binding-decorator/decorator/fluent_provide.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable @typescript-eslint/explicit-function-return-type */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+const provide_in_when_on_syntax_1 = __importDefault(require("../syntax/provide_in_when_on_syntax"));
+const provide_when_syntax_1 = __importDefault(require("../syntax/provide_when_syntax"));
+const provide_on_syntax_1 = __importDefault(require("../syntax/provide_on_syntax"));
+const provide_in_syntax_1 = __importDefault(require("../syntax/provide_in_syntax"));
+const provide_done_syntax_1 = __importDefault(require("../syntax/provide_done_syntax"));
+function fluentProvide(serviceIdentifier) {
+    const bindingWhenOnSyntax = (bind, target) => bind(serviceIdentifier).to(target);
+    const bindingConstraintFunction = (bind, target) => bindingWhenOnSyntax(bind, target)._binding;
+    const provideDoneSyntax = new provide_done_syntax_1.default(bindingConstraintFunction);
+    const provideInWhenOnSyntax = new provide_in_when_on_syntax_1.default(new provide_in_syntax_1.default((bind, target) => bindingWhenOnSyntax(bind, target), provideDoneSyntax), new provide_when_syntax_1.default(bindingWhenOnSyntax, provideDoneSyntax), new provide_on_syntax_1.default(bindingWhenOnSyntax, provideDoneSyntax));
+    return provideInWhenOnSyntax;
+}
+exports.default = fluentProvide;

package/lib/cjs/di/binding-decorator/decorator/provide.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable @typescript-eslint/no-explicit-any */
+require("reflect-metadata");
+const inversify_1 = require("../../inversify");
+const constants_1 = require("../constants");
+function provide(serviceIdentifier, force) {
+    return function (target) {
+        const isAlreadyDecorated = Reflect.hasOwnMetadata(inversify_1.METADATA_KEY.PARAM_TYPES, target);
+        const redecorateWithInject = force === true;
+        if (redecorateWithInject === true && isAlreadyDecorated === false) {
+            (0, inversify_1.decorate)((0, inversify_1.injectable)(), target);
+        }
+        else if (redecorateWithInject === true && isAlreadyDecorated === true) {
+            // Do nothing
+        }
+        else {
+            try {
+                (0, inversify_1.decorate)((0, inversify_1.injectable)(), target);
+            }
+            catch (e) {
+                throw new Error("Cannot apply @provide decorator multiple times but is has been used " +
+                    `multiple times in ${target.name} ` +
+                    "Please use @provide(ID, true) if you are trying to declare multiple bindings!");
+            }
+        }
+        const currentMetadata = {
+            constraint: (bind, bindTarget) => bind(serviceIdentifier).to(bindTarget),
+            implementationType: target,
+        };
+        const previousMetadata = Reflect.getMetadata(constants_1.METADATA_KEY.provide, Reflect) || [];
+        const newMetadata = [currentMetadata, ...previousMetadata];
+        Reflect.defineMetadata(constants_1.METADATA_KEY.provide, newMetadata, Reflect);
+        return target;
+    };
+}
+exports.default = provide;

package/lib/cjs/di/binding-decorator/factory/module_factory.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable @typescript-eslint/no-explicit-any */
+require("reflect-metadata");
+const constants_1 = require("../constants");
+const inversify_1 = require("../../inversify");
+function buildProviderModule() {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    return new inversify_1.ContainerModule((bind, unbind) => {
+        const provideMetadata = Reflect.getMetadata(constants_1.METADATA_KEY.provide, Reflect) || [];
+        provideMetadata.map((metadata) => resolve(metadata, bind));
+    });
+}
+function resolve(metadata, bind) {
+    return metadata.constraint(bind, metadata.implementationType);
+}
+exports.default = buildProviderModule;

package/lib/cjs/di/binding-decorator/index.js

@@ -0,0 +1,14 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildProviderModule = exports.autoProvide = exports.provide = exports.fluentProvide = void 0;
+const auto_wire_1 = __importDefault(require("./utils/auto_wire"));
+exports.autoProvide = auto_wire_1.default;
+const provide_1 = __importDefault(require("./decorator/provide"));
+exports.provide = provide_1.default;
+const fluent_provide_1 = __importDefault(require("./decorator/fluent_provide"));
+exports.fluentProvide = fluent_provide_1.default;
+const module_factory_1 = __importDefault(require("./factory/module_factory"));
+exports.buildProviderModule = module_factory_1.default;

package/lib/cjs/di/binding-decorator/syntax/provide_done_syntax.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const inversify_1 = require("../../inversify");
+const constants_1 = require("../constants");
+class ProvideDoneSyntax {
+    constructor(binding) {
+        this._binding = binding;
+    }
+    done(force) {
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        const that = this;
+        return function (target) {
+            const isAlreadyDecorated = Reflect.hasOwnMetadata(inversify_1.METADATA_KEY.PARAM_TYPES, target);
+            const redecorateWithInject = force === true;
+            if (redecorateWithInject === true && isAlreadyDecorated === false) {
+                (0, inversify_1.decorate)((0, inversify_1.injectable)(), target);
+            }
+            else if (redecorateWithInject === true && isAlreadyDecorated === true) {
+                // Do nothing
+            }
+            else {
+                try {
+                    (0, inversify_1.decorate)((0, inversify_1.injectable)(), target);
+                }
+                catch (e) {
+                    throw new Error("Cannot apply @fluentProvide decorator multiple times but is has been used " +
+                        `multiple times in ${target.name} ` +
+                        "Please use done(true) if you are trying to declare multiple bindings!");
+                }
+            }
+            const currentMetadata = {
+                constraint: that._binding,
+                implementationType: target,
+            };
+            const previousMetadata = Reflect.getMetadata(constants_1.METADATA_KEY.provide, Reflect) || [];
+            const newMetadata = [currentMetadata, ...previousMetadata];
+            Reflect.defineMetadata(constants_1.METADATA_KEY.provide, newMetadata, Reflect);
+            return target;
+        };
+    }
+}
+exports.default = ProvideDoneSyntax;

package/lib/cjs/di/binding-decorator/syntax/provide_in_syntax.js

@@ -0,0 +1,33 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const provide_when_on_syntax_1 = __importDefault(require("./provide_when_on_syntax"));
+const provide_when_syntax_1 = __importDefault(require("./provide_when_syntax"));
+const provide_on_syntax_1 = __importDefault(require("./provide_on_syntax"));
+const provide_done_syntax_1 = __importDefault(require("./provide_done_syntax"));
+class ProvideInSyntax {
+    constructor(bindingInSyntax, provideDoneSyntax) {
+        this._bindingInSyntax = bindingInSyntax;
+        this._provideDoneSyntax = provideDoneSyntax;
+    }
+    inSingletonScope() {
+        const bindingWhenOnSyntax = (bind, target) => this._bindingInSyntax(bind, target).inSingletonScope();
+        const inDoneSyntax = new provide_done_syntax_1.default(bindingWhenOnSyntax);
+        const provideWhenSyntax = new provide_when_syntax_1.default(bindingWhenOnSyntax, inDoneSyntax);
+        const provideOnSyntax = new provide_on_syntax_1.default(bindingWhenOnSyntax, inDoneSyntax);
+        return new provide_when_on_syntax_1.default(provideWhenSyntax, provideOnSyntax);
+    }
+    inTransientScope() {
+        const bindingWhenOnSyntax = (bind, target) => this._bindingInSyntax(bind, target).inTransientScope();
+        const inDoneSyntax = new provide_done_syntax_1.default(bindingWhenOnSyntax);
+        const provideWhenSyntax = new provide_when_syntax_1.default(bindingWhenOnSyntax, inDoneSyntax);
+        const provideOnSyntax = new provide_on_syntax_1.default(bindingWhenOnSyntax, inDoneSyntax);
+        return new provide_when_on_syntax_1.default(provideWhenSyntax, provideOnSyntax);
+    }
+    done(force) {
+        return this._provideDoneSyntax.done(force);
+    }
+}
+exports.default = ProvideInSyntax;

package/lib/cjs/di/binding-decorator/syntax/provide_in_when_on_syntax.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class ProvideInWhenOnSyntax {
+    constructor(provideInSyntax, provideWhenSyntax, provideOnSyntax) {
+        this._provideInSyntax = provideInSyntax;
+        this._provideWhenSyntax = provideWhenSyntax;
+        this._provideOnSyntax = provideOnSyntax;
+    }
+    when(constraint) {
+        return this._provideWhenSyntax.when(constraint);
+    }
+    whenTargetNamed(name) {
+        return this._provideWhenSyntax.whenTargetNamed(name);
+    }
+    whenTargetTagged(tag, value) {
+        return this._provideWhenSyntax.whenTargetTagged(tag, value);
+    }
+    whenInjectedInto(parent) {
+        return this._provideWhenSyntax.whenInjectedInto(parent);
+    }
+    whenParentNamed(name) {
+        return this._provideWhenSyntax.whenParentNamed(name);
+    }
+    whenParentTagged(tag, value) {
+        return this._provideWhenSyntax.whenParentTagged(tag, value);
+    }
+    whenAnyAncestorIs(ancestor) {
+        return this._provideWhenSyntax.whenAnyAncestorIs(ancestor);
+    }
+    whenNoAncestorIs(ancestor) {
+        return this._provideWhenSyntax.whenNoAncestorIs(ancestor);
+    }
+    whenAnyAncestorNamed(name) {
+        return this._provideWhenSyntax.whenAnyAncestorNamed(name);
+    }
+    whenAnyAncestorTagged(tag, value) {
+        return this._provideWhenSyntax.whenAnyAncestorTagged(tag, value);
+    }
+    whenNoAncestorNamed(name) {
+        return this._provideWhenSyntax.whenNoAncestorNamed(name);
+    }
+    whenNoAncestorTagged(tag, value) {
+        return this._provideWhenSyntax.whenNoAncestorTagged(tag, value);
+    }
+    whenAnyAncestorMatches(constraint) {
+        return this._provideWhenSyntax.whenAnyAncestorMatches(constraint);
+    }
+    whenNoAncestorMatches(constraint) {
+        return this._provideWhenSyntax.whenNoAncestorMatches(constraint);
+    }
+    onActivation(fn) {
+        return this._provideOnSyntax.onActivation(fn);
+    }
+    inSingletonScope() {
+        return this._provideInSyntax.inSingletonScope();
+    }
+    inTransientScope() {
+        return this._provideInSyntax.inTransientScope();
+    }
+    done(force) {
+        return this._provideInSyntax.done(force);
+    }
+}
+exports.default = ProvideInWhenOnSyntax;

package/lib/cjs/di/binding-decorator/syntax/provide_on_syntax.js

@@ -0,0 +1,22 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const provide_when_syntax_1 = __importDefault(require("./provide_when_syntax"));
+const provide_done_syntax_1 = __importDefault(require("./provide_done_syntax"));
+class ProvideOnSyntax {
+    constructor(bindingOnSyntax, provideDoneSyntax) {
+        this._bindingOnSyntax = bindingOnSyntax;
+        this._provideDoneSyntax = provideDoneSyntax;
+    }
+    onActivation(fn) {
+        const bindingWhenSyntax = (bind, target) => this._bindingOnSyntax(bind, target).onActivation(fn);
+        const onDoneSyntax = new provide_done_syntax_1.default(bindingWhenSyntax);
+        return new provide_when_syntax_1.default(bindingWhenSyntax, onDoneSyntax);
+    }
+    done(force) {
+        return this._provideDoneSyntax.done(force);
+    }
+}
+exports.default = ProvideOnSyntax;

package/lib/cjs/di/binding-decorator/syntax/provide_when_on_syntax.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class ProvideWhenOnSyntax {
+    constructor(provideWhenSyntax, provideOnSyntax) {
+        this._provideWhenSyntax = provideWhenSyntax;
+        this._provideOnSyntax = provideOnSyntax;
+    }
+    when(constraint) {
+        return this._provideWhenSyntax.when(constraint);
+    }
+    whenTargetNamed(name) {
+        return this._provideWhenSyntax.whenTargetNamed(name);
+    }
+    whenTargetTagged(tag, value) {
+        return this._provideWhenSyntax.whenTargetTagged(tag, value);
+    }
+    whenInjectedInto(parent) {
+        return this._provideWhenSyntax.whenInjectedInto(parent);
+    }
+    whenParentNamed(name) {
+        return this._provideWhenSyntax.whenParentNamed(name);
+    }
+    whenParentTagged(tag, value) {
+        return this._provideWhenSyntax.whenParentTagged(tag, value);
+    }
+    whenAnyAncestorIs(ancestor) {
+        return this._provideWhenSyntax.whenAnyAncestorIs(ancestor);
+    }
+    whenNoAncestorIs(ancestor) {
+        return this._provideWhenSyntax.whenNoAncestorIs(ancestor);
+    }
+    whenAnyAncestorNamed(name) {
+        return this._provideWhenSyntax.whenAnyAncestorNamed(name);
+    }
+    whenAnyAncestorTagged(tag, value) {
+        return this._provideWhenSyntax.whenAnyAncestorTagged(tag, value);
+    }
+    whenNoAncestorNamed(name) {
+        return this._provideWhenSyntax.whenNoAncestorNamed(name);
+    }
+    whenNoAncestorTagged(tag, value) {
+        return this._provideWhenSyntax.whenNoAncestorTagged(tag, value);
+    }
+    whenAnyAncestorMatches(constraint) {
+        return this._provideWhenSyntax.whenAnyAncestorMatches(constraint);
+    }
+    whenNoAncestorMatches(constraint) {
+        return this._provideWhenSyntax.whenNoAncestorMatches(constraint);
+    }
+    onActivation(fn) {
+        return this._provideOnSyntax.onActivation(fn);
+    }
+    done(force) {
+        return this._provideWhenSyntax.done(force);
+    }
+}
+exports.default = ProvideWhenOnSyntax;

package/lib/cjs/di/binding-decorator/syntax/provide_when_syntax.js

@@ -0,0 +1,89 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const provide_on_syntax_1 = __importDefault(require("./provide_on_syntax"));
+const provide_done_syntax_1 = __importDefault(require("./provide_done_syntax"));
+class ProvideWhenSyntax {
+    constructor(bindingWhenSyntax, provideDoneSyntax) {
+        this._bindingWhenSyntax = bindingWhenSyntax;
+        this._provideDoneSyntax = provideDoneSyntax;
+    }
+    when(constraint) {
+        const bindingOnSyntax = (bind, target) => {
+            return this._bindingWhenSyntax(bind, target).when(constraint);
+        };
+        const whenDoneSyntax = new provide_done_syntax_1.default(bindingOnSyntax);
+        return new provide_on_syntax_1.default(bindingOnSyntax, whenDoneSyntax);
+    }
+    whenTargetNamed(name) {
+        const bindingOnSyntax = (bind, target) => this._bindingWhenSyntax(bind, target).whenTargetNamed(name);
+        const whenDoneSyntax = new provide_done_syntax_1.default(bindingOnSyntax);
+        return new provide_on_syntax_1.default(bindingOnSyntax, whenDoneSyntax);
+    }
+    whenTargetTagged(tag, value) {
+        const bindingOnSyntax = (bind, target) => this._bindingWhenSyntax(bind, target).whenTargetTagged(tag, value);
+        const whenDoneSyntax = new provide_done_syntax_1.default(bindingOnSyntax);
+        return new provide_on_syntax_1.default(bindingOnSyntax, whenDoneSyntax);
+    }
+    whenInjectedInto(parent) {
+        const bindingOnSyntax = (bind, target) => this._bindingWhenSyntax(bind, target).whenInjectedInto(parent);
+        const whenDoneSyntax = new provide_done_syntax_1.default(bindingOnSyntax);
+        return new provide_on_syntax_1.default(bindingOnSyntax, whenDoneSyntax);
+    }
+    whenParentNamed(name) {
+        const bindingOnSyntax = (bind, target) => this._bindingWhenSyntax(bind, target).whenParentNamed(name);
+        const whenDoneSyntax = new provide_done_syntax_1.default(bindingOnSyntax);
+        return new provide_on_syntax_1.default(bindingOnSyntax, whenDoneSyntax);
+    }
+    whenParentTagged(tag, value) {
+        const bindingOnSyntax = (bind, target) => this._bindingWhenSyntax(bind, target).whenParentTagged(tag, value);
+        const whenDoneSyntax = new provide_done_syntax_1.default(bindingOnSyntax);
+        return new provide_on_syntax_1.default(bindingOnSyntax, whenDoneSyntax);
+    }
+    whenAnyAncestorIs(ancestor) {
+        const bindingOnSyntax = (bind, target) => this._bindingWhenSyntax(bind, target).whenAnyAncestorIs(ancestor);
+        const whenDoneSyntax = new provide_done_syntax_1.default(bindingOnSyntax);
+        return new provide_on_syntax_1.default(bindingOnSyntax, whenDoneSyntax);
+    }
+    whenNoAncestorIs(ancestor) {
+        const bindingOnSyntax = (bind, target) => this._bindingWhenSyntax(bind, target).whenNoAncestorIs(ancestor);
+        const whenDoneSyntax = new provide_done_syntax_1.default(bindingOnSyntax);
+        return new provide_on_syntax_1.default(bindingOnSyntax, whenDoneSyntax);
+    }
+    whenAnyAncestorNamed(name) {
+        const bindingOnSyntax = (bind, target) => this._bindingWhenSyntax(bind, target).whenAnyAncestorNamed(name);
+        const whenDoneSyntax = new provide_done_syntax_1.default(bindingOnSyntax);
+        return new provide_on_syntax_1.default(bindingOnSyntax, whenDoneSyntax);
+    }
+    whenAnyAncestorTagged(tag, value) {
+        const bindingOnSyntax = (bind, target) => this._bindingWhenSyntax(bind, target).whenAnyAncestorTagged(tag, value);
+        const whenDoneSyntax = new provide_done_syntax_1.default(bindingOnSyntax);
+        return new provide_on_syntax_1.default(bindingOnSyntax, whenDoneSyntax);
+    }
+    whenNoAncestorNamed(name) {
+        const bindingOnSyntax = (bind, target) => this._bindingWhenSyntax(bind, target).whenNoAncestorNamed(name);
+        const whenDoneSyntax = new provide_done_syntax_1.default(bindingOnSyntax);
+        return new provide_on_syntax_1.default(bindingOnSyntax, whenDoneSyntax);
+    }
+    whenNoAncestorTagged(tag, value) {
+        const bindingOnSyntax = (bind, target) => this._bindingWhenSyntax(bind, target).whenNoAncestorTagged(tag, value);
+        const whenDoneSyntax = new provide_done_syntax_1.default(bindingOnSyntax);
+        return new provide_on_syntax_1.default(bindingOnSyntax, whenDoneSyntax);
+    }
+    whenAnyAncestorMatches(constraint) {
+        const bindingOnSyntax = (bind, target) => this._bindingWhenSyntax(bind, target).whenAnyAncestorMatches(constraint);
+        const whenDoneSyntax = new provide_done_syntax_1.default(bindingOnSyntax);
+        return new provide_on_syntax_1.default(bindingOnSyntax, whenDoneSyntax);
+    }
+    whenNoAncestorMatches(constraint) {
+        const bindingOnSyntax = (bind, target) => this._bindingWhenSyntax(bind, target).whenNoAncestorMatches(constraint);
+        const whenDoneSyntax = new provide_done_syntax_1.default(bindingOnSyntax);
+        return new provide_on_syntax_1.default(bindingOnSyntax, whenDoneSyntax);
+    }
+    done(force) {
+        return this._provideDoneSyntax.done(force);
+    }
+}
+exports.default = ProvideWhenSyntax;