@dipscope/type-manager 7.2.1 → 8.0.1

package/dist/es2015/type-metadata.js

@@ -1,200 +1,381 @@
-import { first, isEmpty, isFunction, isNil, isUndefined } from 'lodash';
-import { CustomContext } from './custom-context';
+import { DEFAULT_VALUE_RESOLVER } from './constants/default-value-resolver';
+import { EMPTY_ARRAY } from './constants/empty-array';
+import { EMPTY_MAP } from './constants/empty-map';
+import { NULL_VALUE_RESOLVER } from './constants/null-value-resolver';
 import { getOwnReflectMetadata } from './functions/get-own-reflect-metadata';
 import { nameOf } from './functions/name-of';
 import { InjectMetadata } from './inject-metadata';
 import { Metadata } from './metadata';
 import { PropertyMetadata } from './property-metadata';
-import { typeExtensionMetadataCtorSetKey } from './type-extension-metadata-ctor-set-key';
+import { TYPE_EXTENSION_METADATA_CTOR_SET_KEY } from './type-extension-metadata-ctor-set-key';
+import { ResolvedTypeState } from './type-states/resolved-type-state';
+import { UnresolvedTypeState } from './type-states/unresolved-type-state';
 export class TypeMetadata extends Metadata {
-    constructor(typeManager, typeFn, typeOptions, parentTypeMetadatas) {
-        super(typeManager);
-        this.childrenTypeMetadataMap = new Map();
-        this.discriminantMap = new Map();
-        this.propertyMetadataMap = new Map();
-        this.injectMetadataMap = new Map();
+    constructor(typeManager, typeFnMap, typeMetadataSet, typeFn, typeOptions, parentTypeMetadata) {
+        super(typeManager, typeFnMap);
         this.typeName = nameOf(typeFn);
         this.typeFn = typeFn;
+        this.parentTypeMetadata = parentTypeMetadata;
         this.typeOptionsBase = typeManager.typeOptionsBase;
         this.typeOptions = this.constructTypeOptions(typeOptions);
-        this.typeInternals = this.constructTypeInternals();
-        this.parentTypeMetadatas = parentTypeMetadatas;
-        this.deriveParentTypeMetadataProperties();
-        this.hasDiscriminant(this.discriminant);
+        this.typeMetadataSet = typeMetadataSet;
+        this.currentTypeFnMap = typeFnMap;
+        this.currentChildTypeMetadataMap = new Map();
+        this.currentPropertyMetadataMap = new Map();
+        this.currentInjectMetadataMap = new Map();
+        this.currentTypeState = new UnresolvedTypeState(this);
+        this.extendParentTypeMetadata();
         this.configure(typeOptions);
         return;
     }
-    get parentTypeMetadata() {
-        return first(this.parentTypeMetadatas);
+    get typeState() {
+        return this.currentTypeState;
     }
-    get alias() {
-        return this.typeOptions.alias;
+    get injectMetadataMap() {
+        return this.currentTypeState.injectMetadataMap;
     }
-    get customOptions() {
-        return this.typeOptions.customOptions;
+    get propertyMetadataMap() {
+        return this.currentTypeState.propertyMetadataMap;
     }
-    get customContext() {
-        let customContext = this.typeInternals.customContext;
-        if (isNil(customContext)) {
-            this.typeOptions.customOptions = new Array();
-            this.typeInternals.customContext = new CustomContext(this.typeOptions.customOptions);
-            customContext = this.typeInternals.customContext;
-        }
-        return customContext;
+    get alias() {
+        return this.currentTypeState.alias;
+    }
+    get customValueMap() {
+        return this.currentTypeState.customValueMap;
     }
     get serializedNullValue() {
-        if (this.preserveNull) {
-            return null;
-        }
-        return this.serializedDefaultValue;
+        return this.currentTypeState.serializedNullValueResolver();
     }
     get serializedDefaultValue() {
-        var _a;
-        if (this.useDefaultValue) {
-            const serializedDefaultValue = (_a = this.typeOptions.defaultValue) !== null && _a !== void 0 ? _a : this.typeOptions.serializedDefaultValue;
-            const defaultValue = isFunction(serializedDefaultValue)
-                ? serializedDefaultValue()
-                : serializedDefaultValue;
-            return defaultValue;
-        }
-        return undefined;
+        return this.currentTypeState.serializedDefaultValueResolver();
     }
     get deserializedNullValue() {
-        if (this.preserveNull) {
-            return null;
-        }
-        return this.deserializedDefaultValue;
+        return this.currentTypeState.deserializedNullValueResolver();
     }
     get deserializedDefaultValue() {
-        var _a;
-        if (this.useDefaultValue) {
-            const deserializedDefaultValue = (_a = this.typeOptions.defaultValue) !== null && _a !== void 0 ? _a : this.typeOptions.deserializedDefaultValue;
-            const defaultValue = isFunction(deserializedDefaultValue)
-                ? deserializedDefaultValue()
-                : deserializedDefaultValue;
-            return defaultValue;
-        }
-        return undefined;
+        return this.currentTypeState.deserializedDefaultValueResolver();
     }
     get discriminant() {
-        var _a;
-        return (_a = this.typeOptions.discriminant) !== null && _a !== void 0 ? _a : this.typeName;
+        return this.currentTypeState.discriminant;
     }
     get discriminator() {
-        var _a;
-        return (_a = this.typeOptions.discriminator) !== null && _a !== void 0 ? _a : this.typeOptionsBase.discriminator;
+        return this.currentTypeState.discriminator;
     }
     get factory() {
-        var _a;
-        return (_a = this.typeOptions.factory) !== null && _a !== void 0 ? _a : this.typeOptionsBase.factory;
+        return this.currentTypeState.factory;
     }
     get injectable() {
-        return this.typeOptions.injectable;
+        return this.currentTypeState.injectable;
     }
     get injector() {
-        var _a;
-        return (_a = this.typeOptions.injector) !== null && _a !== void 0 ? _a : this.typeOptionsBase.injector;
+        return this.currentTypeState.injector;
     }
-    get log() {
-        var _a;
-        return (_a = this.typeOptions.log) !== null && _a !== void 0 ? _a : this.typeOptionsBase.log;
+    get logger() {
+        return this.currentTypeState.logger;
     }
     get namingConvention() {
-        var _a;
-        return (_a = this.typeOptions.namingConvention) !== null && _a !== void 0 ? _a : this.typeOptionsBase.namingConvention;
+        return this.currentTypeState.namingConvention;
     }
     get polymorphic() {
-        return this.discriminantMap.size > 1;
+        return this.currentTypeState.polymorphic;
     }
     get preserveDiscriminator() {
-        var _a;
-        return (_a = this.typeOptions.preserveDiscriminator) !== null && _a !== void 0 ? _a : this.typeOptionsBase.preserveDiscriminator;
+        return this.currentTypeState.preserveDiscriminator;
     }
     get referenceHandler() {
-        var _a;
-        return (_a = this.typeOptions.referenceHandler) !== null && _a !== void 0 ? _a : this.typeOptionsBase.referenceHandler;
+        return this.currentTypeState.referenceHandler;
     }
     get serializer() {
-        var _a;
-        return (_a = this.typeOptions.serializer) !== null && _a !== void 0 ? _a : this.typeOptionsBase.serializer;
+        return this.currentTypeState.serializer;
     }
     get preserveNull() {
-        var _a;
-        return (_a = this.typeOptions.preserveNull) !== null && _a !== void 0 ? _a : this.typeOptionsBase.preserveNull;
+        return this.currentTypeState.preserveNull;
     }
     get useDefaultValue() {
-        var _a;
-        return (_a = this.typeOptions.useDefaultValue) !== null && _a !== void 0 ? _a : this.typeOptionsBase.useDefaultValue;
+        return this.currentTypeState.useDefaultValue;
     }
     get useImplicitConversion() {
-        var _a;
-        return (_a = this.typeOptions.useImplicitConversion) !== null && _a !== void 0 ? _a : this.typeOptionsBase.useImplicitConversion;
+        return this.currentTypeState.useImplicitConversion;
     }
     get propertySorter() {
-        var _a;
-        return (_a = this.typeOptions.propertySorter) !== null && _a !== void 0 ? _a : this.typeOptionsBase.propertySorter;
+        return this.currentTypeState.propertySorter;
     }
     get sortedPropertyMetadatas() {
-        const propertySorter = this.propertySorter;
-        const propertyMetadatas = this.propertyMetadataMap.values();
-        if (isNil(propertySorter)) {
-            return propertyMetadatas;
-        }
-        const sortedPropertyMetadatas = Array.from(propertyMetadatas).sort(propertySorter.sort);
-        return sortedPropertyMetadatas[Symbol.iterator]();
+        return this.currentTypeState.sortedPropertyMetadatas;
     }
     get injectSorter() {
-        var _a;
-        return (_a = this.typeOptions.injectSorter) !== null && _a !== void 0 ? _a : this.typeOptionsBase.injectSorter;
+        return this.currentTypeState.injectSorter;
     }
     get sortedInjectMetadatas() {
-        const injectSorter = this.injectSorter;
-        const injectMetadatas = this.injectMetadataMap.values();
-        if (isNil(injectSorter)) {
-            return injectMetadatas;
-        }
-        const sortedInjectMetadatas = Array.from(injectMetadatas).sort(injectSorter.sort);
-        return sortedInjectMetadatas[Symbol.iterator]();
+        return this.currentTypeState.sortedInjectMetadatas;
+    }
+    get parentTypeArguments() {
+        return this.currentTypeState.parentTypeArguments;
     }
     get propertyOptionsMap() {
-        let propertyOptionsMap = this.typeOptions.propertyOptionsMap;
-        if (isNil(propertyOptionsMap)) {
-            propertyOptionsMap = new Map();
-            this.typeOptions.propertyOptionsMap = propertyOptionsMap;
-        }
-        return propertyOptionsMap;
+        return this.currentTypeState.propertyOptionsMap;
     }
     get injectOptionsMap() {
-        let injectOptionsMap = this.typeOptions.injectOptionsMap;
-        if (isNil(injectOptionsMap)) {
-            injectOptionsMap = new Map();
-            this.typeOptions.injectOptionsMap = injectOptionsMap;
-        }
-        return injectOptionsMap;
-    }
-    get parentTypeFns() {
-        return this.typeOptions.parentTypeFns;
+        return this.currentTypeState.injectOptionsMap;
     }
     constructTypeOptions(typeOptions) {
+        if (typeOptions.customValueMap === undefined) {
+            typeOptions.customValueMap = new Map();
+        }
+        if (typeOptions.propertyOptionsMap === undefined) {
+            typeOptions.propertyOptionsMap = new Map();
+        }
+        if (typeOptions.injectOptionsMap === undefined) {
+            typeOptions.injectOptionsMap = new Map();
+        }
         return typeOptions;
     }
-    constructTypeInternals() {
-        const customOptions = this.typeOptions.customOptions;
-        const customContext = isNil(customOptions) ? undefined : new CustomContext(customOptions);
-        const typeInternals = { customContext: customContext };
-        return typeInternals;
+    configureTypeExtensionMetadata(typeExtensionMetadataCtor, typeExtensionOptions) {
+        const typeExtensionMetadataCtorSet = this.extractTypeExtensionMetadataCtorSet();
+        if (!typeExtensionMetadataCtorSet.has(typeExtensionMetadataCtor)) {
+            typeExtensionMetadataCtorSet.add(typeExtensionMetadataCtor);
+        }
+        const initialTypeExtensionOptions = typeExtensionOptions !== null && typeExtensionOptions !== void 0 ? typeExtensionOptions : {};
+        const typeExtensionMetadata = new typeExtensionMetadataCtor(this, initialTypeExtensionOptions);
+        return typeExtensionMetadata;
+    }
+    extractTypeExtensionMetadata(typeExtensionMetadataCtor) {
+        const typeExtensionMetadataCtorSet = this.extractTypeExtensionMetadataCtorSet();
+        if (!typeExtensionMetadataCtorSet.has(typeExtensionMetadataCtor)) {
+            return undefined;
+        }
+        const initialTypeExtensionOptions = {};
+        const typeExtensionMetadata = new typeExtensionMetadataCtor(this, initialTypeExtensionOptions);
+        return typeExtensionMetadata;
     }
-    deriveParentTypeMetadataProperties() {
-        if (isEmpty(this.parentTypeMetadatas)) {
-            return this;
+    extractTypeExtensionMetadataCtorSet() {
+        let customValueMap = this.typeOptions.customValueMap;
+        if (customValueMap === undefined) {
+            customValueMap = new Map();
+            this.typeOptions.customValueMap = customValueMap;
+        }
+        let typeExtensionMetadataCtorSet = customValueMap.get(TYPE_EXTENSION_METADATA_CTOR_SET_KEY);
+        if (typeExtensionMetadataCtorSet === undefined) {
+            typeExtensionMetadataCtorSet = new Set();
+            customValueMap.set(TYPE_EXTENSION_METADATA_CTOR_SET_KEY, typeExtensionMetadataCtorSet);
+        }
+        return typeExtensionMetadataCtorSet;
+    }
+    resolveTypeState() {
+        const typeOptionsBase = this.typeOptionsBase;
+        const typeOptions = this.typeOptions;
+        const typeName = this.typeName;
+        const alias = typeOptions.alias;
+        const customValueMap = this.resolveCustomValueMap();
+        const preserveNull = typeOptions.preserveNull === undefined
+            ? typeOptionsBase.preserveNull
+            : typeOptions.preserveNull;
+        const useDefaultValue = typeOptions.useDefaultValue === undefined
+            ? typeOptionsBase.useDefaultValue
+            : typeOptions.useDefaultValue;
+        const useImplicitConversion = typeOptions.useImplicitConversion === undefined
+            ? typeOptionsBase.useImplicitConversion
+            : typeOptions.useImplicitConversion;
+        const serializedDefaultValue = typeOptions.defaultValue === undefined
+            ? typeOptions.serializedDefaultValue
+            : typeOptions.defaultValue;
+        const serializedDefaultValueResolver = useDefaultValue
+            ? (typeof serializedDefaultValue === 'function' ? serializedDefaultValue : () => serializedDefaultValue)
+            : DEFAULT_VALUE_RESOLVER;
+        const serializedNullValueResolver = preserveNull
+            ? NULL_VALUE_RESOLVER
+            : serializedDefaultValueResolver;
+        const deserializedDefaultValue = typeOptions.defaultValue === undefined
+            ? typeOptions.deserializedDefaultValue
+            : typeOptions.defaultValue;
+        const deserializedDefaultValueResolver = useDefaultValue
+            ? (typeof deserializedDefaultValue === 'function' ? deserializedDefaultValue : () => deserializedDefaultValue)
+            : DEFAULT_VALUE_RESOLVER;
+        const deserializedNullValueResolver = preserveNull
+            ? NULL_VALUE_RESOLVER
+            : deserializedDefaultValueResolver;
+        const discriminant = typeOptions.discriminant === undefined
+            ? typeName
+            : typeOptions.discriminant;
+        const discriminator = typeOptions.discriminator === undefined
+            ? typeOptionsBase.discriminator
+            : typeOptions.discriminator;
+        const factory = typeOptions.factory === undefined
+            ? typeOptionsBase.factory
+            : typeOptions.factory;
+        const injectable = typeOptions.injectable === true;
+        const injector = typeOptions.injector === undefined
+            ? typeOptionsBase.injector
+            : typeOptions.injector;
+        const logger = typeOptions.logger === undefined
+            ? typeOptionsBase.logger
+            : typeOptions.logger;
+        const namingConvention = typeOptions.namingConvention === undefined
+            ? typeOptionsBase.namingConvention
+            : typeOptions.namingConvention;
+        const parentTypeArguments = typeOptions.parentTypeArguments === undefined
+            ? EMPTY_ARRAY
+            : typeOptions.parentTypeArguments;
+        const ownParentTypeMetadatas = this.resolveOwnParentTypeMetadatas(parentTypeArguments);
+        const ownChildTypeMetadatas = this.resolveOwnChildTypeMetadatas();
+        const parentTypeMetadataSet = this.resolveParentTypeMetadataSet(this);
+        const parentTypeMetadatas = Array.from(parentTypeMetadataSet);
+        const childTypeMetadataSet = this.resolveChildTypeMetadataSet(this);
+        const childTypeMetadatas = Array.from(childTypeMetadataSet);
+        const typeMetadataMap = new Map();
+        const polymorphic = childTypeMetadatas.length > 1;
+        for (let i = 0; i < childTypeMetadatas.length; i++) {
+            const childTypeMetadata = childTypeMetadatas[i];
+            typeMetadataMap.set(childTypeMetadata.typeFn, childTypeMetadata);
+        }
+        const preserveDiscriminator = typeOptions.preserveDiscriminator === undefined
+            ? typeOptionsBase.preserveDiscriminator
+            : typeOptions.preserveDiscriminator;
+        const referenceHandler = typeOptions.referenceHandler === undefined
+            ? typeOptionsBase.referenceHandler
+            : typeOptions.referenceHandler;
+        const serializer = typeOptions.serializer === undefined
+            ? typeOptionsBase.serializer
+            : typeOptions.serializer;
+        const propertySorter = typeOptions.propertySorter === undefined
+            ? typeOptionsBase.propertySorter
+            : typeOptions.propertySorter;
+        const ownPropertyMetadataMap = this.currentPropertyMetadataMap;
+        const propertyMetadataMap = this.resolvePropertyMetadataMap(parentTypeMetadatas);
+        const sortedPropertyMetadatas = propertySorter === undefined
+            ? Array.from(propertyMetadataMap.values())
+            : Array.from(propertyMetadataMap.values()).sort(propertySorter.sort);
+        const injectMetadataMap = this.currentInjectMetadataMap;
+        const injectSorter = typeOptions.injectSorter === undefined
+            ? typeOptionsBase.injectSorter
+            : typeOptions.injectSorter;
+        const sortedInjectMetadatas = injectSorter === undefined
+            ? Array.from(injectMetadataMap.values())
+            : Array.from(injectMetadataMap.values()).sort(injectSorter.sort);
+        const propertyOptionsMap = typeOptions.propertyOptionsMap === undefined
+            ? EMPTY_MAP
+            : typeOptions.propertyOptionsMap;
+        const injectOptionsMap = typeOptions.injectOptionsMap === undefined
+            ? EMPTY_MAP
+            : typeOptions.injectOptionsMap;
+        const resolvedTypeState = new ResolvedTypeState(this, alias, customValueMap, serializedNullValueResolver, serializedDefaultValue, serializedDefaultValueResolver, deserializedNullValueResolver, deserializedDefaultValue, deserializedDefaultValueResolver, discriminant, discriminator, factory, injectable, injector, logger, namingConvention, polymorphic, typeMetadataMap, preserveDiscriminator, referenceHandler, serializer, preserveNull, useDefaultValue, useImplicitConversion, propertySorter, sortedPropertyMetadatas, injectSorter, sortedInjectMetadatas, parentTypeArguments, parentTypeMetadatas, ownParentTypeMetadatas, childTypeMetadatas, ownChildTypeMetadatas, propertyOptionsMap, propertyMetadataMap, ownPropertyMetadataMap, injectOptionsMap, injectMetadataMap);
+        this.currentTypeState = resolvedTypeState;
+        return resolvedTypeState;
+    }
+    unresolveTypeState() {
+        const unresolvedTypeState = new UnresolvedTypeState(this);
+        this.currentTypeState = unresolvedTypeState;
+        return unresolvedTypeState;
+    }
+    resolveCustomValueMap() {
+        const typeOptionsBase = this.typeOptionsBase;
+        const typeOptions = this.typeOptions;
+        const customValueMap = new Map();
+        if (typeOptions.customValueMap === undefined) {
+            return customValueMap;
+        }
+        const baseCustomValueMap = typeOptionsBase.customValueMap === undefined
+            ? EMPTY_MAP
+            : typeOptionsBase.customValueMap;
+        for (const [customKey, customValue] of typeOptions.customValueMap) {
+            if (customValue === undefined) {
+                customValueMap.set(customKey, baseCustomValueMap.get(customKey));
+                continue;
+            }
+            customValueMap.set(customKey, customValue);
+        }
+        return customValueMap;
+    }
+    resolveOwnParentTypeMetadatas(parentTypeArguments) {
+        const ownParentTypeMetadatas = new Array();
+        const parentTypeMetadatas = this.resolveTypeMetadatas(parentTypeArguments);
+        for (let i = parentTypeMetadatas.length - 1; i >= 0; i--) {
+            ownParentTypeMetadatas.push(parentTypeMetadatas[i]);
+        }
+        if (this.parentTypeMetadata !== undefined) {
+            ownParentTypeMetadatas.push(this.parentTypeMetadata);
+        }
+        return ownParentTypeMetadatas;
+    }
+    resolveOwnChildTypeMetadatas() {
+        const ownChildTypeMetadatas = new Array();
+        for (const childTypeMetadata of this.currentChildTypeMetadataMap.values()) {
+            ownChildTypeMetadatas.push(childTypeMetadata);
+        }
+        for (const setTypeMetadata of this.typeMetadataSet) {
+            const typeOptions = setTypeMetadata.typeOptions;
+            const parentTypeArguments = typeOptions.parentTypeArguments === undefined
+                ? EMPTY_ARRAY
+                : typeOptions.parentTypeArguments;
+            const parentTypeMetadatas = this.resolveTypeMetadatas(parentTypeArguments);
+            for (let i = 0; i < parentTypeMetadatas.length; i++) {
+                if (parentTypeMetadatas[i] === this) {
+                    ownChildTypeMetadatas.push(setTypeMetadata);
+                    break;
+                }
+            }
         }
-        for (const parentTypeMetadata of this.parentTypeMetadatas) {
-            for (const [propertyName, propertyMetadata] of parentTypeMetadata.propertyMetadataMap) {
-                if (!this.propertyMetadataMap.has(propertyName)) {
-                    this.propertyMetadataMap.set(propertyName, propertyMetadata);
+        return ownChildTypeMetadatas;
+    }
+    resolveParentTypeMetadataSet(typeMetadata, parentTypeMetadataSet = new Set()) {
+        if (parentTypeMetadataSet.has(typeMetadata)) {
+            return parentTypeMetadataSet;
+        }
+        parentTypeMetadataSet.add(typeMetadata);
+        const typeOptions = typeMetadata.typeOptions;
+        const parentTypeArguments = typeOptions.parentTypeArguments === undefined
+            ? EMPTY_ARRAY
+            : typeOptions.parentTypeArguments;
+        const parentTypeMetadatas = this.resolveTypeMetadatas(parentTypeArguments);
+        for (let i = parentTypeMetadatas.length - 1; i >= 0; i--) {
+            this.resolveParentTypeMetadataSet(parentTypeMetadatas[i], parentTypeMetadataSet);
+        }
+        if (typeMetadata.parentTypeMetadata !== undefined) {
+            this.resolveParentTypeMetadataSet(typeMetadata.parentTypeMetadata, parentTypeMetadataSet);
+        }
+        return parentTypeMetadataSet;
+    }
+    resolveChildTypeMetadataSet(typeMetadata, childTypeMetadataSet = new Set()) {
+        if (childTypeMetadataSet.has(typeMetadata)) {
+            return childTypeMetadataSet;
+        }
+        childTypeMetadataSet.add(typeMetadata);
+        for (const childTypeMetadata of typeMetadata.currentChildTypeMetadataMap.values()) {
+            this.resolveChildTypeMetadataSet(childTypeMetadata, childTypeMetadataSet);
+            childTypeMetadata.unresolveTypeState();
+        }
+        for (const setTypeMetadata of this.typeMetadataSet) {
+            const typeOptions = setTypeMetadata.typeOptions;
+            const parentTypeArguments = typeOptions.parentTypeArguments === undefined
+                ? EMPTY_ARRAY
+                : typeOptions.parentTypeArguments;
+            const parentTypeMetadatas = this.resolveTypeMetadatas(parentTypeArguments);
+            for (let i = 0; i < parentTypeMetadatas.length; i++) {
+                if (parentTypeMetadatas[i] === typeMetadata) {
+                    this.resolveChildTypeMetadataSet(setTypeMetadata, childTypeMetadataSet);
+                    setTypeMetadata.unresolveTypeState();
+                    break;
                 }
             }
-            parentTypeMetadata.childrenTypeMetadataMap.set(this.typeFn, this);
+        }
+        return childTypeMetadataSet;
+    }
+    resolvePropertyMetadataMap(parentTypeMetadatas) {
+        const propertyMetadataMap = new Map();
+        for (let i = parentTypeMetadatas.length - 1; i >= 0; i--) {
+            for (const [propertyName, propertyMetadata] of parentTypeMetadatas[i].currentPropertyMetadataMap) {
+                propertyMetadataMap.set(propertyName, propertyMetadata);
+            }
+        }
+        for (const propertyMetadata of this.currentPropertyMetadataMap.values()) {
+            propertyMetadata.unresolvePropertyState();
+        }
+        return propertyMetadataMap;
+    }
+    extendParentTypeMetadata() {
+        const parentTypeMetadata = this.parentTypeMetadata;
+        if (parentTypeMetadata !== undefined) {
+            parentTypeMetadata.currentChildTypeMetadataMap.set(this.typeFn, this);
         }
         return this;
     }
@@ -205,8 +386,8 @@ export class TypeMetadata extends Metadata {
         }
         const injectTypeFns = ((_a = getOwnReflectMetadata('design:paramtypes', this.typeFn)) !== null && _a !== void 0 ? _a : new Array());
         for (let injectIndex = 0; injectIndex < injectTypeFns.length; injectIndex++) {
-            if (!this.injectMetadataMap.has(injectIndex)) {
-                this.configureInjectMetadata(injectIndex, { typeFn: injectTypeFns[injectIndex] });
+            if (!this.currentInjectMetadataMap.has(injectIndex)) {
+                this.configureInjectMetadata(injectIndex, { typeArgument: injectTypeFns[injectIndex] });
             }
         }
         return this;
@@ -214,258 +395,316 @@ export class TypeMetadata extends Metadata {
     hasAlias(alias) {
         this.releaseAlias();
         this.typeOptions.alias = alias;
-        if (!isNil(alias)) {
-            this.typeFnMap.set(alias, this.typeFn);
+        if (alias !== undefined) {
+            this.currentTypeFnMap.set(alias, this.typeFn);
         }
+        this.currentTypeState = new UnresolvedTypeState(this);
         return this;
     }
     releaseAlias() {
-        const alias = this.alias;
-        if (!isNil(alias) && this.typeFnMap.has(alias)) {
-            this.typeFnMap.delete(alias);
+        const alias = this.typeOptions.alias;
+        if (alias !== undefined && this.currentTypeFnMap.has(alias)) {
+            this.currentTypeFnMap.delete(alias);
+        }
+        return this;
+    }
+    hasCustomValueMap(customValueMap) {
+        let currentCustomValueMap = this.typeOptions.customValueMap;
+        if (currentCustomValueMap === undefined) {
+            currentCustomValueMap = new Map();
+            this.typeOptions.customValueMap = currentCustomValueMap;
+        }
+        if (customValueMap !== undefined) {
+            if (currentCustomValueMap !== customValueMap) {
+                currentCustomValueMap.clear();
+            }
+            for (const [customKey, customValue] of customValueMap) {
+                currentCustomValueMap.set(customKey, customValue);
+            }
         }
+        this.currentTypeState = new UnresolvedTypeState(this);
         return this;
     }
-    hasCustomOption(customKey, customValue) {
-        this.customContext.set(customKey, customValue);
+    hasCustomValue(customKey, customValue) {
+        let customValueMap = this.typeOptions.customValueMap;
+        if (customValueMap === undefined) {
+            customValueMap = new Map();
+            this.typeOptions.customValueMap = customValueMap;
+        }
+        customValueMap.set(customKey, customValue);
+        this.currentTypeState = new UnresolvedTypeState(this);
         return this;
     }
-    extractCustomOption(customKey) {
-        return this.customContext.get(customKey);
+    extractCustomValue(customKey) {
+        let customValue = this.typeState.customValueMap.get(customKey);
+        if (customValue === undefined && customKey.customValueResolver !== undefined) {
+            customValue = customKey.customValueResolver();
+        }
+        return customValue;
     }
     hasCustomOptions(customOptions) {
-        if (!isNil(customOptions)) {
-            this.customContext.configure(customOptions);
+        let customValueMap = this.typeOptions.customValueMap;
+        if (customValueMap === undefined) {
+            customValueMap = new Map();
+            this.typeOptions.customValueMap = customValueMap;
         }
+        for (let i = 0; i < customOptions.length; i++) {
+            customValueMap.set(customOptions[i][0], customOptions[i][1]);
+        }
+        this.currentTypeState = new UnresolvedTypeState(this);
         return this;
     }
     hasDefaultValue(defaultValue) {
         this.typeOptions.defaultValue = defaultValue;
+        this.currentTypeState = new UnresolvedTypeState(this);
         return this;
     }
     hasSerializedDefaultValue(serializedDefaultValue) {
         this.typeOptions.serializedDefaultValue = serializedDefaultValue;
+        this.currentTypeState = new UnresolvedTypeState(this);
         return this;
     }
     hasDeserializedDefaultValue(deserializedDefaultValue) {
         this.typeOptions.deserializedDefaultValue = deserializedDefaultValue;
+        this.currentTypeState = new UnresolvedTypeState(this);
         return this;
     }
     hasDiscriminator(discriminator) {
         this.typeOptions.discriminator = discriminator;
+        this.currentTypeState = new UnresolvedTypeState(this);
         return this;
     }
     hasDiscriminant(discriminant) {
         this.typeOptions.discriminant = discriminant;
-        if (!isNil(discriminant)) {
-            this.provideDiscriminant(this.typeFn, discriminant);
-        }
-        return this;
-    }
-    provideDiscriminant(typeFn, discriminant) {
-        this.discriminantMap.set(typeFn, discriminant);
-        if (!isEmpty(this.parentTypeMetadatas)) {
-            for (const parentTypeMetadata of this.parentTypeMetadatas) {
-                parentTypeMetadata.provideDiscriminant(typeFn, discriminant);
-            }
-        }
+        this.currentTypeState = new UnresolvedTypeState(this);
         return this;
     }
     hasFactory(factory) {
         this.typeOptions.factory = factory;
+        this.currentTypeState = new UnresolvedTypeState(this);
         return this;
     }
     isInjectable(injectable = true) {
         this.typeOptions.injectable = injectable;
+        this.currentTypeState = new UnresolvedTypeState(this);
         return this;
     }
     hasInjector(injector) {
         this.typeOptions.injector = injector;
+        this.currentTypeState = new UnresolvedTypeState(this);
         return this;
     }
-    hasLog(log) {
-        this.typeOptions.log = log;
+    hasLogger(logger) {
+        this.typeOptions.logger = logger;
+        this.currentTypeState = new UnresolvedTypeState(this);
         return this;
     }
     hasNamingConvention(namingConvention) {
         this.typeOptions.namingConvention = namingConvention;
+        this.currentTypeState = new UnresolvedTypeState(this);
         return this;
     }
     shouldPreserveDiscriminator(preserveDiscriminator = true) {
         this.typeOptions.preserveDiscriminator = preserveDiscriminator;
+        this.currentTypeState = new UnresolvedTypeState(this);
         return this;
     }
     hasReferenceHandler(referenceHandler) {
         this.typeOptions.referenceHandler = referenceHandler;
+        this.currentTypeState = new UnresolvedTypeState(this);
         return this;
     }
     hasSerializer(serializer) {
         this.typeOptions.serializer = serializer;
+        this.currentTypeState = new UnresolvedTypeState(this);
         return this;
     }
     shouldPreserveNull(preserveNull = true) {
         this.typeOptions.preserveNull = preserveNull;
+        this.currentTypeState = new UnresolvedTypeState(this);
         return this;
     }
     shouldUseDefaultValue(useDefaultValue = true) {
         this.typeOptions.useDefaultValue = useDefaultValue;
+        this.currentTypeState = new UnresolvedTypeState(this);
         return this;
     }
     shouldUseImplicitConversion(useImplicitConversion = true) {
         this.typeOptions.useImplicitConversion = useImplicitConversion;
+        this.currentTypeState = new UnresolvedTypeState(this);
         return this;
     }
     hasPropertySorter(propertySorter) {
         this.typeOptions.propertySorter = propertySorter;
+        this.currentTypeState = new UnresolvedTypeState(this);
         return this;
     }
     hasInjectSorter(injectSorter) {
         this.typeOptions.injectSorter = injectSorter;
+        this.currentTypeState = new UnresolvedTypeState(this);
+        return this;
+    }
+    hasParentTypeArguments(parentTypeArguments) {
+        this.typeOptions.parentTypeArguments = parentTypeArguments;
+        this.currentTypeState = new UnresolvedTypeState(this);
         return this;
     }
     configurePropertyMetadata(propertyName, propertyOptions) {
-        let propertyMetadata = this.propertyMetadataMap.get(propertyName);
-        if (isNil(propertyMetadata)) {
-            propertyMetadata = new PropertyMetadata(this, propertyName, propertyOptions !== null && propertyOptions !== void 0 ? propertyOptions : {});
-            this.propertyMetadataMap.set(propertyName, propertyMetadata);
-            this.propertyOptionsMap.set(propertyName, propertyMetadata.propertyOptions);
+        let propertyOptionsMap = this.typeOptions.propertyOptionsMap;
+        if (propertyOptionsMap === undefined) {
+            propertyOptionsMap = new Map();
+            this.typeOptions.propertyOptionsMap = propertyOptionsMap;
+        }
+        let propertyMetadata = this.currentPropertyMetadataMap.get(propertyName);
+        if (propertyMetadata === undefined) {
+            propertyOptions = propertyOptions !== null && propertyOptions !== void 0 ? propertyOptions : {};
+            propertyMetadata = new PropertyMetadata(this.typeManager, this.currentTypeFnMap, this, propertyName, propertyOptions);
+            this.currentPropertyMetadataMap.set(propertyName, propertyMetadata);
+            propertyOptionsMap.set(propertyName, propertyOptions);
+            this.currentTypeState = new UnresolvedTypeState(this);
             return propertyMetadata;
         }
-        if (!isNil(propertyOptions)) {
+        if (propertyOptions !== undefined) {
             propertyMetadata.configure(propertyOptions);
         }
+        this.currentTypeState = new UnresolvedTypeState(this);
         return propertyMetadata;
     }
     configureInjectMetadata(injectIndex, injectOptions) {
-        let injectMetadata = this.injectMetadataMap.get(injectIndex);
-        if (isNil(injectMetadata)) {
-            injectMetadata = new InjectMetadata(this, injectIndex, injectOptions !== null && injectOptions !== void 0 ? injectOptions : {});
-            this.injectMetadataMap.set(injectIndex, injectMetadata);
-            this.injectOptionsMap.set(injectIndex, injectMetadata.injectOptions);
+        let injectOptionsMap = this.typeOptions.injectOptionsMap;
+        if (injectOptionsMap === undefined) {
+            injectOptionsMap = new Map();
+            this.typeOptions.injectOptionsMap = injectOptionsMap;
+        }
+        let injectMetadata = this.currentInjectMetadataMap.get(injectIndex);
+        if (injectMetadata === undefined) {
+            injectOptions = injectOptions !== null && injectOptions !== void 0 ? injectOptions : {};
+            injectMetadata = new InjectMetadata(this.typeManager, this.currentTypeFnMap, this, injectIndex, injectOptions);
+            this.currentInjectMetadataMap.set(injectIndex, injectMetadata);
+            injectOptionsMap.set(injectIndex, injectOptions);
+            this.currentTypeState = new UnresolvedTypeState(this);
             return injectMetadata;
         }
-        if (!isNil(injectOptions)) {
+        if (injectOptions !== undefined) {
             injectMetadata.configure(injectOptions);
         }
+        this.currentTypeState = new UnresolvedTypeState(this);
         return injectMetadata;
     }
     hasPropertyMetadataMap(propertyOptionsMap) {
+        const currentPropertyOptionsMap = this.clearPropertyOptionsMap(propertyOptionsMap);
         for (const [propertyName, propertyOptions] of propertyOptionsMap) {
-            this.configurePropertyMetadata(propertyName, propertyOptions);
+            const propertyMetadata = new PropertyMetadata(this.typeManager, this.currentTypeFnMap, this, propertyName, propertyOptions);
+            this.currentPropertyMetadataMap.set(propertyName, propertyMetadata);
+            currentPropertyOptionsMap.set(propertyName, propertyOptions);
         }
+        this.currentTypeState = new UnresolvedTypeState(this);
         return this;
     }
-    hasInjectMetadataMap(injectOptionsMap) {
-        for (const [injectIndex, injectOptions] of injectOptionsMap) {
-            this.configureInjectMetadata(injectIndex, injectOptions);
+    clearPropertyOptionsMap(propertyOptionsMap) {
+        let currentPropertyOptionsMap = this.typeOptions.propertyOptionsMap;
+        if (currentPropertyOptionsMap === undefined) {
+            currentPropertyOptionsMap = new Map();
+            this.typeOptions.propertyOptionsMap = currentPropertyOptionsMap;
         }
-        return this;
-    }
-    configureTypeExtensionMetadata(typeExtensionMetadataCtor, typeExtensionOptions) {
-        const typeExtensionMetadataCtorSet = this.extractCustomOption(typeExtensionMetadataCtorSetKey);
-        if (!typeExtensionMetadataCtorSet.has(typeExtensionMetadataCtor)) {
-            typeExtensionMetadataCtorSet.add(typeExtensionMetadataCtor);
+        if (currentPropertyOptionsMap !== propertyOptionsMap) {
+            currentPropertyOptionsMap.clear();
+            this.currentPropertyMetadataMap.clear();
         }
-        const initialTypeExtensionOptions = typeExtensionOptions !== null && typeExtensionOptions !== void 0 ? typeExtensionOptions : {};
-        const typeExtensionMetadata = new typeExtensionMetadataCtor(this, initialTypeExtensionOptions);
-        return typeExtensionMetadata;
+        return currentPropertyOptionsMap;
     }
-    extractTypeExtensionMetadata(typeExtensionMetadataCtor) {
-        const typeExtensionMetadataCtorSet = this.extractCustomOption(typeExtensionMetadataCtorSetKey);
-        if (!typeExtensionMetadataCtorSet.has(typeExtensionMetadataCtor)) {
-            return undefined;
+    hasInjectMetadataMap(injectOptionsMap) {
+        const currentInjectOptionsMap = this.clearInjectOptionsMap(injectOptionsMap);
+        for (const [injectIndex, injectOptions] of injectOptionsMap) {
+            const injectMetadata = new InjectMetadata(this.typeManager, this.currentTypeFnMap, this, injectIndex, injectOptions);
+            this.currentInjectMetadataMap.set(injectIndex, injectMetadata);
+            currentInjectOptionsMap.set(injectIndex, injectOptions);
         }
-        const initialTypeExtensionOptions = {};
-        const typeExtensionMetadata = new typeExtensionMetadataCtor(this, initialTypeExtensionOptions);
-        return typeExtensionMetadata;
+        this.currentTypeState = new UnresolvedTypeState(this);
+        return this;
     }
-    hasParentTypeFns(parentTypeFns) {
-        if (isNil(this.typeOptions.parentTypeFns)) {
-            this.typeOptions.parentTypeFns = new Array();
+    clearInjectOptionsMap(injectOptionsMap) {
+        let currentInjectOptionsMap = this.typeOptions.injectOptionsMap;
+        if (currentInjectOptionsMap === undefined) {
+            currentInjectOptionsMap = new Map();
+            this.typeOptions.injectOptionsMap = currentInjectOptionsMap;
         }
-        for (const parentTypeFn of parentTypeFns) {
-            const parentTypeMetadata = this.typeManager.extractTypeMetadata(parentTypeFn);
-            if (!this.parentTypeMetadatas.some(ptm => ptm === parentTypeMetadata)) {
-                this.parentTypeMetadatas.push(parentTypeMetadata);
-            }
-            if (!this.typeOptions.parentTypeFns.some(ptf => ptf === parentTypeFn)) {
-                this.typeOptions.parentTypeFns.push(parentTypeFn);
-            }
+        if (currentInjectOptionsMap !== injectOptionsMap) {
+            currentInjectOptionsMap.clear();
+            this.currentInjectMetadataMap.clear();
         }
-        this.deriveParentTypeMetadataProperties();
-        this.hasDiscriminant(this.discriminant);
-        return this;
+        return currentInjectOptionsMap;
     }
     configure(typeOptions) {
-        if (!isUndefined(typeOptions.parentTypeFns)) {
-            this.hasParentTypeFns(typeOptions.parentTypeFns);
-        }
-        if (!isUndefined(typeOptions.alias)) {
+        if (typeOptions.alias !== undefined) {
             this.hasAlias(typeOptions.alias);
         }
-        if (!isUndefined(typeOptions.customOptions)) {
-            this.hasCustomOptions(typeOptions.customOptions);
+        if (typeOptions.customValueMap !== undefined) {
+            this.hasCustomValueMap(typeOptions.customValueMap);
         }
-        if (!isUndefined(typeOptions.defaultValue)) {
+        if (typeOptions.defaultValue !== undefined) {
             this.hasDefaultValue(typeOptions.defaultValue);
         }
-        if (!isUndefined(typeOptions.serializedDefaultValue)) {
+        if (typeOptions.serializedDefaultValue !== undefined) {
             this.hasSerializedDefaultValue(typeOptions.serializedDefaultValue);
         }
-        if (!isUndefined(typeOptions.deserializedDefaultValue)) {
+        if (typeOptions.deserializedDefaultValue !== undefined) {
             this.hasDeserializedDefaultValue(typeOptions.deserializedDefaultValue);
         }
-        if (!isUndefined(typeOptions.discriminator)) {
+        if (typeOptions.discriminator !== undefined) {
             this.hasDiscriminator(typeOptions.discriminator);
         }
-        if (!isUndefined(typeOptions.discriminant)) {
+        if (typeOptions.discriminant !== undefined) {
             this.hasDiscriminant(typeOptions.discriminant);
         }
-        if (!isUndefined(typeOptions.factory)) {
+        if (typeOptions.factory !== undefined) {
             this.hasFactory(typeOptions.factory);
         }
-        if (!isUndefined(typeOptions.injectable)) {
+        if (typeOptions.injectable !== undefined) {
             this.isInjectable(typeOptions.injectable);
         }
-        if (!isUndefined(typeOptions.injector)) {
+        if (typeOptions.injector !== undefined) {
             this.hasInjector(typeOptions.injector);
         }
-        if (!isUndefined(typeOptions.log)) {
-            this.hasLog(typeOptions.log);
+        if (typeOptions.logger !== undefined) {
+            this.hasLogger(typeOptions.logger);
         }
-        if (!isUndefined(typeOptions.namingConvention)) {
+        if (typeOptions.namingConvention !== undefined) {
             this.hasNamingConvention(typeOptions.namingConvention);
         }
-        if (!isUndefined(typeOptions.preserveDiscriminator)) {
+        if (typeOptions.preserveDiscriminator !== undefined) {
             this.shouldPreserveDiscriminator(typeOptions.preserveDiscriminator);
         }
-        if (!isUndefined(typeOptions.referenceHandler)) {
+        if (typeOptions.referenceHandler !== undefined) {
             this.hasReferenceHandler(typeOptions.referenceHandler);
         }
-        if (!isUndefined(typeOptions.serializer)) {
+        if (typeOptions.serializer !== undefined) {
             this.hasSerializer(typeOptions.serializer);
         }
-        if (!isUndefined(typeOptions.preserveNull)) {
+        if (typeOptions.preserveNull !== undefined) {
             this.shouldPreserveNull(typeOptions.preserveNull);
         }
-        if (!isUndefined(typeOptions.useDefaultValue)) {
+        if (typeOptions.useDefaultValue !== undefined) {
             this.shouldUseDefaultValue(typeOptions.useDefaultValue);
         }
-        if (!isUndefined(typeOptions.useImplicitConversion)) {
+        if (typeOptions.useImplicitConversion !== undefined) {
             this.shouldUseImplicitConversion(typeOptions.useImplicitConversion);
         }
-        if (!isUndefined(typeOptions.propertyOptionsMap)) {
+        if (typeOptions.propertyOptionsMap !== undefined) {
             this.hasPropertyMetadataMap(typeOptions.propertyOptionsMap);
         }
-        if (!isUndefined(typeOptions.injectOptionsMap)) {
+        if (typeOptions.injectOptionsMap !== undefined) {
             this.hasInjectMetadataMap(typeOptions.injectOptionsMap);
         }
-        if (!isUndefined(typeOptions.propertySorter)) {
+        if (typeOptions.propertySorter !== undefined) {
             this.hasPropertySorter(typeOptions.propertySorter);
         }
-        if (!isUndefined(typeOptions.injectSorter)) {
+        if (typeOptions.injectSorter !== undefined) {
             this.hasInjectSorter(typeOptions.injectSorter);
         }
+        if (typeOptions.parentTypeArguments !== undefined) {
+            this.hasParentTypeArguments(typeOptions.parentTypeArguments);
+        }
         return this;
     }
 }