@expressots/core 3.0.0-beta.4 → 4.0.0-preview.1

package/lib/esm/di/container-introspection.js

@@ -0,0 +1,38 @@
+/**
+ * Visit every binding in the container, including duplicates registered
+ * for the same service identifier. Returns the total count visited.
+ */
+export function forEachBinding(container, visit) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const dict = container._bindingDictionary;
+    if (!dict)
+        return 0;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const map = dict._map;
+    if (!map)
+        return 0;
+    let count = 0;
+    for (const [serviceIdentifier, bindings] of map) {
+        for (const binding of bindings) {
+            visit(binding, serviceIdentifier);
+            count++;
+        }
+    }
+    return count;
+}
+/**
+ * Returns every implementation type currently bound in the container
+ * that is a real constructor function. Filters out factory and value
+ * bindings.
+ */
+export function getBoundImplementations(container) {
+    const out = [];
+    forEachBinding(container, (binding) => {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const impl = binding.implementationType;
+        if (typeof impl === "function") {
+            out.push(impl);
+        }
+    });
+    return out;
+}

package/lib/esm/di/interfaces/interfaces.js

@@ -0,0 +1 @@
+export {};

package/lib/esm/di/inversify.js

@@ -0,0 +1,53 @@
+/**
+ * InversifyJS Dependency Injection Library
+ *
+ * @layer public
+ * @audience application-developers
+ * @concept dependency-injection
+ * @difficulty intermediate
+ *
+ * @summary Quick Start
+ * ExpressoTS uses InversifyJS for dependency injection. Most InversifyJS APIs are available here.
+ *
+ * @example
+ * ```typescript
+ * import { Container, injectable, inject } from "@expressots/core";
+ *
+ * @injectable()
+ * export class MyService {
+ *   constructor(@inject("IDependency") private dep: IDependency) {}
+ * }
+ * ```
+ *
+ * @note
+ * This module re-exports InversifyJS APIs. For full InversifyJS documentation,
+ * see: https://github.com/inversify/InversifyJS
+ *
+ * @public API
+ */
+import * as keys from "./constants/metadata_keys.js";
+export const METADATA_KEY = keys;
+export { Container } from "./container/container.js";
+export { Scope, BindingTypeEnum, TargetTypeEnum, } from "./constants/literal_types.js";
+export { AsyncContainerModule, ContainerModule, } from "./container/container_module.js";
+export { createTaggedDecorator } from "./annotation/decorator_utils.js";
+export { injectable } from "./annotation/injectable.js";
+export { tagged } from "./annotation/tagged.js";
+export { named } from "./annotation/named.js";
+export { inject } from "./annotation/inject.js";
+export { LazyServiceIdentifier } from "./annotation/lazy_service_identifier.js";
+export { LazyServiceIdentifier as LazyServiceIdentifer } from "./annotation/lazy_service_identifier.js";
+export { optional } from "./annotation/optional.js";
+export { unmanaged } from "./annotation/unmanaged.js";
+export { multiInject } from "./annotation/multi_inject.js";
+export { targetName } from "./annotation/target_name.js";
+export { postConstruct } from "./annotation/post_construct.js";
+export { preDestroy } from "./annotation/pre_destroy.js";
+export { MetadataReader } from "./planning/metadata_reader.js";
+export { id } from "./utils/id.js";
+export { decorate } from "./annotation/decorator_utils.js";
+export { forEachBinding, getBoundImplementations, } from "./container-introspection.js";
+export { traverseAncerstors, taggedConstraint, namedConstraint, typeConstraint, } from "./syntax/constraint_helpers.js";
+export { getServiceIdentifierAsString } from "./utils/serialization.js";
+export { multiBindToService } from "./utils/binding_utils.js";
+export { ScopeRegistry, globalScopeRegistry } from "./scope/scope-registry.js";

package/lib/esm/di/planning/context.js

@@ -0,0 +1,18 @@
+import { id } from "../utils/id.js";
+class Context {
+    id;
+    container;
+    plan;
+    currentRequest;
+    constructor(container) {
+        this.id = id();
+        this.container = container;
+    }
+    addPlan(plan) {
+        this.plan = plan;
+    }
+    setCurrentRequest(currentRequest) {
+        this.currentRequest = currentRequest;
+    }
+}
+export { Context };

package/lib/esm/di/planning/metadata.js

@@ -0,0 +1,18 @@
+import * as METADATA_KEY from "../constants/metadata_keys.js";
+class Metadata {
+    key;
+    value;
+    constructor(key, value) {
+        this.key = key;
+        this.value = value;
+    }
+    toString() {
+        if (this.key === METADATA_KEY.NAMED_TAG) {
+            return `named: ${String(this.value).toString()} `;
+        }
+        else {
+            return `tagged: { key:${this.key.toString()}, value: ${String(this.value)} }`;
+        }
+    }
+}
+export { Metadata };

package/lib/esm/di/planning/metadata_reader.js

@@ -0,0 +1,19 @@
+import * as METADATA_KEY from "../constants/metadata_keys.js";
+class MetadataReader {
+    getConstructorMetadata(constructorFunc) {
+        // TypeScript compiler generated annotations
+        const compilerGeneratedMetadata = Reflect.getMetadata(METADATA_KEY.PARAM_TYPES, constructorFunc);
+        // User generated constructor annotations
+        const userGeneratedMetadata = Reflect.getMetadata(METADATA_KEY.TAGGED, constructorFunc);
+        return {
+            compilerGeneratedMetadata,
+            userGeneratedMetadata: userGeneratedMetadata || {},
+        };
+    }
+    getPropertiesMetadata(constructorFunc) {
+        // User generated properties annotations
+        const userGeneratedMetadata = Reflect.getMetadata(METADATA_KEY.TAGGED_PROP, constructorFunc) || [];
+        return userGeneratedMetadata;
+    }
+}
+export { MetadataReader };

package/lib/esm/di/planning/plan.js

@@ -0,0 +1,9 @@
+class Plan {
+    parentContext;
+    rootRequest;
+    constructor(parentContext, rootRequest) {
+        this.parentContext = parentContext;
+        this.rootRequest = rootRequest;
+    }
+}
+export { Plan };

package/lib/esm/di/planning/planner.js

@@ -0,0 +1,159 @@
+import { BindingCount } from "../bindings/binding_count.js";
+import * as ERROR_MSGS from "../constants/error_msgs.js";
+import { BindingTypeEnum, TargetTypeEnum } from "../constants/literal_types.js";
+import * as METADATA_KEY from "../constants/metadata_keys.js";
+import { isStackOverflowExeption } from "../utils/exceptions.js";
+import { circularDependencyToException, getServiceIdentifierAsString, listMetadataForTarget, listRegisteredBindingsForServiceIdentifier, } from "../utils/serialization.js";
+import { Context } from "./context.js";
+import { Metadata } from "./metadata.js";
+import { Plan } from "./plan.js";
+import { getBaseClassDependencyCount, getDependencies, getFunctionName, } from "./reflection_utils.js";
+import { Request } from "./request.js";
+import { Target } from "./target.js";
+function getBindingDictionary(cntnr) {
+    return cntnr._bindingDictionary;
+}
+function _createTarget(isMultiInject, targetType, serviceIdentifier, name, key, value) {
+    const metadataKey = isMultiInject
+        ? METADATA_KEY.MULTI_INJECT_TAG
+        : METADATA_KEY.INJECT_TAG;
+    const injectMetadata = new Metadata(metadataKey, serviceIdentifier);
+    const target = new Target(targetType, name, serviceIdentifier, injectMetadata);
+    if (key !== undefined) {
+        const tagMetadata = new Metadata(key, value);
+        target.metadata.push(tagMetadata);
+    }
+    return target;
+}
+function _getActiveBindings(metadataReader, avoidConstraints, context, parentRequest, target) {
+    let bindings = getBindings(context.container, target.serviceIdentifier);
+    let activeBindings = [];
+    // automatic binding
+    if (bindings.length === BindingCount.NoBindingsAvailable &&
+        context.container.options.autoBindInjectable &&
+        typeof target.serviceIdentifier === "function" &&
+        metadataReader.getConstructorMetadata(target.serviceIdentifier)
+            .compilerGeneratedMetadata) {
+        context.container.bind(target.serviceIdentifier).toSelf();
+        bindings = getBindings(context.container, target.serviceIdentifier);
+    }
+    // multiple bindings available
+    if (!avoidConstraints) {
+        // apply constraints if available to reduce the number of active bindings
+        activeBindings = bindings.filter((binding) => {
+            const request = new Request(binding.serviceIdentifier, context, parentRequest, binding, target);
+            return binding.constraint(request);
+        });
+    }
+    else {
+        // simple injection or multi-injection without constraints
+        activeBindings = bindings;
+    }
+    // validate active bindings
+    _validateActiveBindingCount(target.serviceIdentifier, activeBindings, target, context.container);
+    return activeBindings;
+}
+function _validateActiveBindingCount(serviceIdentifier, bindings, target, container) {
+    switch (bindings.length) {
+        case BindingCount.NoBindingsAvailable:
+            if (target.isOptional()) {
+                return bindings;
+            }
+            else {
+                const serviceIdentifierString = getServiceIdentifierAsString(serviceIdentifier);
+                let msg = ERROR_MSGS.NOT_REGISTERED;
+                msg += listMetadataForTarget(serviceIdentifierString, target);
+                msg += listRegisteredBindingsForServiceIdentifier(container, serviceIdentifierString, getBindings);
+                throw new Error(msg);
+            }
+        case BindingCount.OnlyOneBindingAvailable:
+            return bindings;
+        case BindingCount.MultipleBindingsAvailable:
+        default:
+            if (!target.isArray()) {
+                const serviceIdentifierString = getServiceIdentifierAsString(serviceIdentifier);
+                let msg = `${ERROR_MSGS.AMBIGUOUS_MATCH} ${serviceIdentifierString}`;
+                msg += listRegisteredBindingsForServiceIdentifier(container, serviceIdentifierString, getBindings);
+                throw new Error(msg);
+            }
+            else {
+                return bindings;
+            }
+    }
+}
+function _createSubRequests(metadataReader, avoidConstraints, serviceIdentifier, context, parentRequest, target) {
+    let activeBindings;
+    let childRequest;
+    if (parentRequest === null) {
+        activeBindings = _getActiveBindings(metadataReader, avoidConstraints, context, null, target);
+        childRequest = new Request(serviceIdentifier, context, null, activeBindings, target);
+        const thePlan = new Plan(context, childRequest);
+        context.addPlan(thePlan);
+    }
+    else {
+        activeBindings = _getActiveBindings(metadataReader, avoidConstraints, context, parentRequest, target);
+        childRequest = parentRequest.addChildRequest(target.serviceIdentifier, activeBindings, target);
+    }
+    activeBindings.forEach((binding) => {
+        let subChildRequest = null;
+        if (target.isArray()) {
+            subChildRequest = childRequest.addChildRequest(binding.serviceIdentifier, binding, target);
+        }
+        else {
+            if (binding.cache) {
+                return;
+            }
+            subChildRequest = childRequest;
+        }
+        if (binding.type === BindingTypeEnum.Instance &&
+            binding.implementationType !== null) {
+            const dependencies = getDependencies(metadataReader, binding.implementationType);
+            if (!context.container.options.skipBaseClassChecks) {
+                // Throw if a derived class does not implement its constructor explicitly
+                // We do this to prevent errors when a base class (parent) has dependencies
+                // and one of the derived classes (children) has no dependencies
+                const baseClassDependencyCount = getBaseClassDependencyCount(metadataReader, binding.implementationType);
+                if (dependencies.length < baseClassDependencyCount) {
+                    const error = ERROR_MSGS.ARGUMENTS_LENGTH_MISMATCH(getFunctionName(binding.implementationType));
+                    throw new Error(error);
+                }
+            }
+            dependencies.forEach((dependency) => {
+                _createSubRequests(metadataReader, false, dependency.serviceIdentifier, context, subChildRequest, dependency);
+            });
+        }
+    });
+}
+function getBindings(container, serviceIdentifier) {
+    let bindings = [];
+    const bindingDictionary = getBindingDictionary(container);
+    if (bindingDictionary.hasKey(serviceIdentifier)) {
+        bindings = bindingDictionary.get(serviceIdentifier);
+    }
+    else if (container.parent !== null) {
+        // recursively try to get bindings from parent container
+        bindings = getBindings(container.parent, serviceIdentifier);
+    }
+    return bindings;
+}
+function plan(metadataReader, container, isMultiInject, targetType, serviceIdentifier, key, value, avoidConstraints = false) {
+    const context = new Context(container);
+    const target = _createTarget(isMultiInject, targetType, serviceIdentifier, "", key, value);
+    try {
+        _createSubRequests(metadataReader, avoidConstraints, serviceIdentifier, context, null, target);
+        return context;
+    }
+    catch (error) {
+        if (isStackOverflowExeption(error)) {
+            circularDependencyToException(context.plan.rootRequest);
+        }
+        throw error;
+    }
+}
+function createMockRequest(container, serviceIdentifier, key, value) {
+    const target = new Target(TargetTypeEnum.Variable, "", serviceIdentifier, new Metadata(key, value));
+    const context = new Context(container);
+    const request = new Request(serviceIdentifier, context, null, [], target);
+    return request;
+}
+export { plan, createMockRequest, getBindingDictionary };

package/lib/esm/di/planning/queryable_string.js

@@ -0,0 +1,25 @@
+class QueryableString {
+    str;
+    constructor(str) {
+        this.str = str;
+    }
+    startsWith(searchString) {
+        return this.str.indexOf(searchString) === 0;
+    }
+    endsWith(searchString) {
+        let reverseString = "";
+        const reverseSearchString = searchString.split("").reverse().join("");
+        reverseString = this.str.split("").reverse().join("");
+        return this.startsWith.call({ str: reverseString }, reverseSearchString);
+    }
+    contains(searchString) {
+        return this.str.indexOf(searchString) !== -1;
+    }
+    equals(compareString) {
+        return this.str === compareString;
+    }
+    value() {
+        return this.str;
+    }
+}
+export { QueryableString };

package/lib/esm/di/planning/reflection_utils.js

@@ -0,0 +1,150 @@
+import { LazyServiceIdentifier } from "../annotation/lazy_service_identifier.js";
+import * as ERROR_MSGS from "../constants/error_msgs.js";
+import { TargetTypeEnum } from "../constants/literal_types.js";
+import * as METADATA_KEY from "../constants/metadata_keys.js";
+import { getFunctionName } from "../utils/serialization.js";
+import { Target } from "./target.js";
+function getDependencies(metadataReader, func) {
+    const constructorName = getFunctionName(func);
+    return getTargets(metadataReader, constructorName, func, false);
+}
+function getTargets(metadataReader, constructorName, func, isBaseClass) {
+    const metadata = metadataReader.getConstructorMetadata(func);
+    // TypeScript compiler generated annotations
+    const serviceIdentifiers = metadata.compilerGeneratedMetadata;
+    // All types resolved must be annotated with @injectable
+    if (serviceIdentifiers === undefined) {
+        const msg = `${ERROR_MSGS.MISSING_INJECTABLE_ANNOTATION} ${constructorName}.`;
+        throw new Error(msg);
+    }
+    // User generated annotations
+    const constructorArgsMetadata = metadata.userGeneratedMetadata;
+    const keys = Object.keys(constructorArgsMetadata);
+    const hasUserDeclaredUnknownInjections = func.length === 0 && keys.length > 0;
+    const hasOptionalParameters = keys.length > func.length;
+    const iterations = hasUserDeclaredUnknownInjections || hasOptionalParameters
+        ? keys.length
+        : func.length;
+    // Target instances that represent constructor arguments to be injected
+    const constructorTargets = getConstructorArgsAsTargets(isBaseClass, constructorName, serviceIdentifiers, constructorArgsMetadata, iterations);
+    // Target instances that represent properties to be injected
+    const propertyTargets = getClassPropsAsTargets(metadataReader, func, constructorName);
+    const targets = [...constructorTargets, ...propertyTargets];
+    return targets;
+}
+function getConstructorArgsAsTarget(index, isBaseClass, constructorName, serviceIdentifiers, constructorArgsMetadata) {
+    // Create map from array of metadata for faster access to metadata
+    const targetMetadata = constructorArgsMetadata[index.toString()] || [];
+    const metadata = formatTargetMetadata(targetMetadata);
+    const isManaged = metadata.unmanaged !== true;
+    // Take types to be injected from user-generated metadata
+    // if not available use compiler-generated metadata
+    let serviceIdentifier = serviceIdentifiers[index];
+    const injectIdentifier = metadata.inject || metadata.multiInject;
+    serviceIdentifier = (injectIdentifier ? injectIdentifier : serviceIdentifier);
+    // we unwrap LazyServiceIdentifier wrappers to allow circular dependencies on symbols
+    if (serviceIdentifier instanceof LazyServiceIdentifier) {
+        serviceIdentifier = serviceIdentifier.unwrap();
+    }
+    // Types Object and Function are too ambiguous to be resolved
+    // user needs to generate metadata manually for those
+    if (isManaged) {
+        const isObject = serviceIdentifier === Object;
+        const isFunction = serviceIdentifier === Function;
+        const isUndefined = serviceIdentifier === undefined;
+        const isUnknownType = isObject || isFunction || isUndefined;
+        if (!isBaseClass && isUnknownType) {
+            const msg = `${ERROR_MSGS.MISSING_INJECT_ANNOTATION} argument ${index} in class ${constructorName}.`;
+            throw new Error(msg);
+        }
+        const target = new Target(TargetTypeEnum.ConstructorArgument, metadata.targetName, serviceIdentifier);
+        target.metadata = targetMetadata;
+        return target;
+    }
+    return null;
+}
+function getConstructorArgsAsTargets(isBaseClass, constructorName, serviceIdentifiers, constructorArgsMetadata, iterations) {
+    const targets = [];
+    for (let i = 0; i < iterations; i++) {
+        const index = i;
+        const target = getConstructorArgsAsTarget(index, isBaseClass, constructorName, serviceIdentifiers, constructorArgsMetadata);
+        if (target !== null) {
+            targets.push(target);
+        }
+    }
+    return targets;
+}
+function _getServiceIdentifierForProperty(inject, multiInject, propertyName, className) {
+    const serviceIdentifier = inject || multiInject;
+    if (serviceIdentifier === undefined) {
+        const msg = `${ERROR_MSGS.MISSING_INJECTABLE_ANNOTATION} for property ${String(propertyName)} in class ${className}.`;
+        throw new Error(msg);
+    }
+    return serviceIdentifier;
+}
+function getClassPropsAsTargets(metadataReader, constructorFunc, constructorName) {
+    const classPropsMetadata = metadataReader.getPropertiesMetadata(constructorFunc);
+    let targets = [];
+    const symbolKeys = Object.getOwnPropertySymbols(classPropsMetadata);
+    const stringKeys = Object.keys(classPropsMetadata);
+    const keys = stringKeys.concat(symbolKeys);
+    for (const key of keys) {
+        // the metadata for the property being injected
+        const targetMetadata = classPropsMetadata[key];
+        // the metadata formatted for easier access
+        const metadata = formatTargetMetadata(targetMetadata);
+        const identifier = metadata.targetName || key;
+        // Take types to be injected from user-generated metadata
+        const serviceIdentifier = _getServiceIdentifierForProperty(metadata.inject, metadata.multiInject, key, constructorName);
+        // The property target
+        const target = new Target(TargetTypeEnum.ClassProperty, identifier, serviceIdentifier);
+        target.metadata = targetMetadata;
+        targets.push(target);
+    }
+    // Check if base class has injected properties
+    const baseConstructor = Object.getPrototypeOf(constructorFunc.prototype).constructor;
+    if (baseConstructor !== Object) {
+        const baseTargets = getClassPropsAsTargets(metadataReader, baseConstructor, constructorName);
+        targets = [...targets, ...baseTargets];
+    }
+    return targets;
+}
+function getBaseClassDependencyCount(metadataReader, func) {
+    const baseConstructor = Object.getPrototypeOf(func.prototype).constructor;
+    if (baseConstructor !== Object) {
+        // get targets for base class
+        const baseConstructorName = getFunctionName(baseConstructor);
+        const targets = getTargets(metadataReader, baseConstructorName, baseConstructor, true);
+        // get unmanaged metadata
+        const metadata = targets.map((t) => t.metadata.filter((m) => m.key === METADATA_KEY.UNMANAGED_TAG));
+        // Compare the number of constructor arguments with the number of
+        // unmanaged dependencies unmanaged dependencies are not required
+        const unmanagedCount = [].concat.apply([], metadata).length;
+        const dependencyCount = targets.length - unmanagedCount;
+        if (dependencyCount > 0) {
+            return dependencyCount;
+        }
+        else {
+            return getBaseClassDependencyCount(metadataReader, baseConstructor);
+        }
+    }
+    else {
+        return 0;
+    }
+}
+// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+function formatTargetMetadata(targetMetadata) {
+    // Create map from array of metadata for faster access to metadata
+    const targetMetadataMap = {};
+    targetMetadata.forEach((m) => {
+        targetMetadataMap[m.key.toString()] = m.value;
+    });
+    // user generated metadata
+    return {
+        inject: targetMetadataMap[METADATA_KEY.INJECT_TAG],
+        multiInject: targetMetadataMap[METADATA_KEY.MULTI_INJECT_TAG],
+        targetName: targetMetadataMap[METADATA_KEY.NAME_TAG],
+        unmanaged: targetMetadataMap[METADATA_KEY.UNMANAGED_TAG],
+    };
+}
+export { getDependencies, getBaseClassDependencyCount, getFunctionName };

package/lib/esm/di/planning/request.js

@@ -0,0 +1,28 @@
+import { id } from "../utils/id.js";
+class Request {
+    id;
+    serviceIdentifier;
+    parentContext;
+    parentRequest;
+    bindings;
+    childRequests;
+    target;
+    requestScope;
+    constructor(serviceIdentifier, parentContext, parentRequest, bindings, target) {
+        this.id = id();
+        this.serviceIdentifier = serviceIdentifier;
+        this.parentContext = parentContext;
+        this.parentRequest = parentRequest;
+        this.target = target;
+        this.childRequests = [];
+        this.bindings = Array.isArray(bindings) ? bindings : [bindings];
+        // Set requestScope if Request is the root request
+        this.requestScope = parentRequest === null ? new Map() : null;
+    }
+    addChildRequest(serviceIdentifier, bindings, target) {
+        const child = new Request(serviceIdentifier, this.parentContext, this, bindings, target);
+        this.childRequests.push(child);
+        return child;
+    }
+}
+export { Request };

package/lib/esm/di/planning/target.js

@@ -0,0 +1,89 @@
+import * as METADATA_KEY from "../constants/metadata_keys.js";
+import { id } from "../utils/id.js";
+import { getSymbolDescription } from "../utils/serialization.js";
+import { Metadata } from "./metadata.js";
+import { QueryableString } from "./queryable_string.js";
+class Target {
+    id;
+    type;
+    serviceIdentifier;
+    name;
+    identifier;
+    key;
+    metadata;
+    constructor(type, identifier, serviceIdentifier, namedOrTagged) {
+        this.id = id();
+        this.type = type;
+        this.serviceIdentifier = serviceIdentifier;
+        const queryableName = typeof identifier === "symbol"
+            ? getSymbolDescription(identifier)
+            : identifier;
+        this.name = new QueryableString(queryableName || "");
+        this.identifier = identifier;
+        this.metadata = new Array();
+        let metadataItem = null;
+        // is named target
+        if (typeof namedOrTagged === "string") {
+            metadataItem = new Metadata(METADATA_KEY.NAMED_TAG, namedOrTagged);
+        }
+        else if (namedOrTagged instanceof Metadata) {
+            // is target with metadata
+            metadataItem = namedOrTagged;
+        }
+        // target has metadata
+        if (metadataItem !== null) {
+            this.metadata.push(metadataItem);
+        }
+    }
+    hasTag(key) {
+        for (const m of this.metadata) {
+            if (m.key === key) {
+                return true;
+            }
+        }
+        return false;
+    }
+    isArray() {
+        return this.hasTag(METADATA_KEY.MULTI_INJECT_TAG);
+    }
+    matchesArray(name) {
+        return this.matchesTag(METADATA_KEY.MULTI_INJECT_TAG)(name);
+    }
+    isNamed() {
+        return this.hasTag(METADATA_KEY.NAMED_TAG);
+    }
+    isTagged() {
+        return this.metadata.some((metadata) => METADATA_KEY.NON_CUSTOM_TAG_KEYS.every((key) => metadata.key !== key));
+    }
+    isOptional() {
+        return this.matchesTag(METADATA_KEY.OPTIONAL_TAG)(true);
+    }
+    getNamedTag() {
+        if (this.isNamed()) {
+            return this.metadata.filter((m) => m.key === METADATA_KEY.NAMED_TAG)[0];
+        }
+        return null;
+    }
+    getCustomTags() {
+        if (this.isTagged()) {
+            return this.metadata.filter((metadata) => METADATA_KEY.NON_CUSTOM_TAG_KEYS.every((key) => metadata.key !== key));
+        }
+        else {
+            return null;
+        }
+    }
+    matchesNamedTag(name) {
+        return this.matchesTag(METADATA_KEY.NAMED_TAG)(name);
+    }
+    matchesTag(key) {
+        return (value) => {
+            for (const m of this.metadata) {
+                if (m.key === key && m.value === value) {
+                    return true;
+                }
+            }
+            return false;
+        };
+    }
+}
+export { Target };