@dipscope/type-manager 7.2.1 → 8.0.1

package/dist/es5/property-metadata.js

@@ -1,399 +1,525 @@
-import { __extends } from "tslib";
-import { isFunction, isNil, isUndefined } from 'lodash';
-import { CustomContext } from './custom-context';
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+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 { getReflectMetadata } from './functions/get-reflect-metadata';
 import { Metadata } from './metadata';
-import { propertyExtensionMetadataCtorSetKey } from './property-extension-metadata-ctor-set-key';
+import { PROPERTY_EXTENSION_METADATA_CTOR_SET_KEY } from './property-extension-metadata-ctor-set-key';
+import { ResolvedPropertyState } from './property-states/resolved-property-state';
+import { UnresolvedPropertyState } from './property-states/unresolved-property-state';
 var PropertyMetadata = (function (_super) {
     __extends(PropertyMetadata, _super);
-    function PropertyMetadata(declaringTypeMetadata, propertyName, propertyOptions) {
-        var _this = _super.call(this, declaringTypeMetadata.typeManager) || this;
+    function PropertyMetadata(typeManager, typeFnMap, declaringTypeMetadata, propertyName, propertyOptions) {
+        var _this = _super.call(this, typeManager, typeFnMap) || this;
         _this.declaringTypeMetadata = declaringTypeMetadata;
         _this.propertyName = propertyName;
+        _this.normalizedPropertyName = propertyName.toLocaleLowerCase();
         _this.reflectTypeFn = getReflectMetadata('design:type', declaringTypeMetadata.typeFn.prototype, propertyName);
         _this.propertyOptions = _this.constructPropertyOptions(propertyOptions);
-        _this.propertyInternals = _this.constructPropertyInternals();
+        _this.currentPropertyState = new UnresolvedPropertyState(_this);
         _this.configure(propertyOptions);
         return _this;
     }
-    Object.defineProperty(PropertyMetadata.prototype, "alias", {
+    Object.defineProperty(PropertyMetadata.prototype, "propertyState", {
         get: function () {
-            return this.propertyOptions.alias;
+            return this.currentPropertyState;
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(PropertyMetadata.prototype, "customOptions", {
+    Object.defineProperty(PropertyMetadata.prototype, "alias", {
         get: function () {
-            return this.propertyOptions.customOptions;
+            return this.currentPropertyState.alias;
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(PropertyMetadata.prototype, "customContext", {
+    Object.defineProperty(PropertyMetadata.prototype, "customValueMap", {
         get: function () {
-            var customContext = this.propertyInternals.customContext;
-            if (isNil(customContext)) {
-                this.propertyOptions.customOptions = new Array();
-                this.propertyInternals.customContext = new CustomContext(this.propertyOptions.customOptions);
-                customContext = this.propertyInternals.customContext;
-            }
-            return customContext;
+            return this.currentPropertyState.customValueMap;
         },
         enumerable: false,
         configurable: true
     });
     Object.defineProperty(PropertyMetadata.prototype, "serializedNullValue", {
         get: function () {
-            if (this.preserveNull) {
-                return null;
-            }
-            return this.serializedDefaultValue;
+            return this.currentPropertyState.serializedNullValueResolver();
         },
         enumerable: false,
         configurable: true
     });
     Object.defineProperty(PropertyMetadata.prototype, "serializedDefaultValue", {
         get: function () {
-            var _a, _b;
-            if (this.useDefaultValue) {
-                var serializedDefaultValue = (_b = (_a = this.propertyOptions.defaultValue) !== null && _a !== void 0 ? _a : this.propertyOptions.serializedDefaultValue) !== null && _b !== void 0 ? _b : this.typeMetadata.serializedDefaultValue;
-                var defaultValue = isFunction(serializedDefaultValue)
-                    ? serializedDefaultValue()
-                    : serializedDefaultValue;
-                return defaultValue;
-            }
-            return undefined;
+            return this.currentPropertyState.serializedDefaultValueResolver();
         },
         enumerable: false,
         configurable: true
     });
     Object.defineProperty(PropertyMetadata.prototype, "deserializedNullValue", {
         get: function () {
-            if (this.preserveNull) {
-                return null;
-            }
-            return this.deserializedDefaultValue;
+            return this.currentPropertyState.deserializedNullValueResolver();
         },
         enumerable: false,
         configurable: true
     });
     Object.defineProperty(PropertyMetadata.prototype, "deserializedDefaultValue", {
         get: function () {
-            var _a, _b;
-            if (this.useDefaultValue) {
-                var deserializedDefaultValue = (_b = (_a = this.propertyOptions.defaultValue) !== null && _a !== void 0 ? _a : this.propertyOptions.deserializedDefaultValue) !== null && _b !== void 0 ? _b : this.typeMetadata.deserializedDefaultValue;
-                var defaultValue = isFunction(deserializedDefaultValue)
-                    ? deserializedDefaultValue()
-                    : deserializedDefaultValue;
-                return defaultValue;
-            }
-            return undefined;
+            return this.currentPropertyState.deserializedDefaultValueResolver();
         },
         enumerable: false,
         configurable: true
     });
     Object.defineProperty(PropertyMetadata.prototype, "serializedPropertyName", {
         get: function () {
-            var _a;
-            var alias = this.alias;
-            if (isNil(alias)) {
-                var namingConvention = (_a = this.namingConvention) !== null && _a !== void 0 ? _a : this.declaringTypeMetadata.namingConvention;
-                var propertyName = namingConvention ? namingConvention.convert(this.propertyName) : this.propertyName;
-                return propertyName;
-            }
-            return alias;
+            return this.currentPropertyState.serializedPropertyName;
         },
         enumerable: false,
         configurable: true
     });
     Object.defineProperty(PropertyMetadata.prototype, "deserializedPropertyName", {
         get: function () {
-            return this.propertyName;
+            return this.currentPropertyState.deserializedPropertyName;
         },
         enumerable: false,
         configurable: true
     });
     Object.defineProperty(PropertyMetadata.prototype, "deserializable", {
         get: function () {
-            return this.propertyOptions.deserializable;
+            return this.currentPropertyState.deserializable;
         },
         enumerable: false,
         configurable: true
     });
     Object.defineProperty(PropertyMetadata.prototype, "genericArguments", {
         get: function () {
-            return this.propertyOptions.genericArguments;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(PropertyMetadata.prototype, "genericStructures", {
-        get: function () {
-            return this.propertyInternals.genericStructures;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(PropertyMetadata.prototype, "genericMetadataResolvers", {
-        get: function () {
-            return this.propertyInternals.genericMetadataResolvers;
+            return this.currentPropertyState.genericArguments;
         },
         enumerable: false,
         configurable: true
     });
     Object.defineProperty(PropertyMetadata.prototype, "genericMetadatas", {
         get: function () {
-            var genericStructures = this.genericStructures;
-            var genericMetadataResolvers = this.genericMetadataResolvers;
-            if (isNil(genericStructures) || isNil(genericMetadataResolvers)) {
-                return undefined;
-            }
-            return this.defineGenericMetadatas(genericStructures, genericMetadataResolvers);
+            return this.currentPropertyState.genericMetadatas;
         },
         enumerable: false,
         configurable: true
     });
     Object.defineProperty(PropertyMetadata.prototype, "namingConvention", {
         get: function () {
-            var _a;
-            return (_a = this.propertyOptions.namingConvention) !== null && _a !== void 0 ? _a : this.typeMetadata.namingConvention;
+            return this.currentPropertyState.namingConvention;
         },
         enumerable: false,
         configurable: true
     });
     Object.defineProperty(PropertyMetadata.prototype, "referenceHandler", {
         get: function () {
-            var _a;
-            return (_a = this.propertyOptions.referenceHandler) !== null && _a !== void 0 ? _a : this.typeMetadata.referenceHandler;
+            return this.currentPropertyState.referenceHandler;
         },
         enumerable: false,
         configurable: true
     });
     Object.defineProperty(PropertyMetadata.prototype, "serializable", {
         get: function () {
-            return this.propertyOptions.serializable;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(PropertyMetadata.prototype, "serializationConfigured", {
-        get: function () {
-            return !isNil(this.serializable) || !isNil(this.deserializable);
+            return this.currentPropertyState.serializable;
         },
         enumerable: false,
         configurable: true
     });
     Object.defineProperty(PropertyMetadata.prototype, "serializer", {
         get: function () {
-            var _a;
-            return (_a = this.propertyOptions.serializer) !== null && _a !== void 0 ? _a : this.typeMetadata.serializer;
+            return this.currentPropertyState.serializer;
         },
         enumerable: false,
         configurable: true
     });
     Object.defineProperty(PropertyMetadata.prototype, "typeArgument", {
         get: function () {
-            return this.propertyOptions.typeArgument;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(PropertyMetadata.prototype, "typeMetadataResolver", {
-        get: function () {
-            return this.propertyInternals.typeMetadataResolver;
+            return this.currentPropertyState.typeArgument;
         },
         enumerable: false,
         configurable: true
     });
     Object.defineProperty(PropertyMetadata.prototype, "typeMetadata", {
         get: function () {
-            return this.typeMetadataResolver(this.typeArgument);
+            return this.currentPropertyState.typeMetadata;
         },
         enumerable: false,
         configurable: true
     });
     Object.defineProperty(PropertyMetadata.prototype, "preserveNull", {
         get: function () {
-            var _a;
-            return (_a = this.propertyOptions.preserveNull) !== null && _a !== void 0 ? _a : this.typeMetadata.preserveNull;
+            return this.currentPropertyState.preserveNull;
         },
         enumerable: false,
         configurable: true
     });
     Object.defineProperty(PropertyMetadata.prototype, "useDefaultValue", {
         get: function () {
-            var _a;
-            return (_a = this.propertyOptions.useDefaultValue) !== null && _a !== void 0 ? _a : this.typeMetadata.useDefaultValue;
+            return this.currentPropertyState.useDefaultValue;
         },
         enumerable: false,
         configurable: true
     });
     Object.defineProperty(PropertyMetadata.prototype, "useImplicitConversion", {
         get: function () {
-            var _a;
-            return (_a = this.propertyOptions.useImplicitConversion) !== null && _a !== void 0 ? _a : this.typeMetadata.useImplicitConversion;
+            return this.currentPropertyState.useImplicitConversion;
         },
         enumerable: false,
         configurable: true
     });
     PropertyMetadata.prototype.constructPropertyOptions = function (propertyOptions) {
-        var _a;
-        propertyOptions.typeArgument = (_a = propertyOptions.typeArgument) !== null && _a !== void 0 ? _a : this.reflectTypeFn;
+        if (propertyOptions.customValueMap === undefined) {
+            propertyOptions.customValueMap = new Map();
+        }
         return propertyOptions;
     };
-    PropertyMetadata.prototype.constructPropertyInternals = function () {
-        var typeMetadataResolver = this.defineTypeMetadataResolver(this.propertyOptions.typeArgument);
-        var customOptions = this.propertyOptions.customOptions;
-        var customContext = isNil(customOptions) ? undefined : new CustomContext(customOptions);
-        var propertyInternals = { typeMetadataResolver: typeMetadataResolver, customContext: customContext };
-        return propertyInternals;
+    PropertyMetadata.prototype.configurePropertyExtensionMetadata = function (propertyExtensionMetadataCtor, propertyExtensionOptions) {
+        var propertyExtensionMetadataCtorSet = this.extractPropertyExtensionMetadataCtorSet();
+        if (!propertyExtensionMetadataCtorSet.has(propertyExtensionMetadataCtor)) {
+            propertyExtensionMetadataCtorSet.add(propertyExtensionMetadataCtor);
+        }
+        var initialPropertyExtensionOptions = propertyExtensionOptions !== null && propertyExtensionOptions !== void 0 ? propertyExtensionOptions : {};
+        var propertyExtensionMetadata = new propertyExtensionMetadataCtor(this, initialPropertyExtensionOptions);
+        return propertyExtensionMetadata;
+    };
+    PropertyMetadata.prototype.extractPropertyExtensionMetadata = function (propertyExtensionMetadataCtor) {
+        var propertyExtensionMetadataCtorSet = this.extractPropertyExtensionMetadataCtorSet();
+        if (!propertyExtensionMetadataCtorSet.has(propertyExtensionMetadataCtor)) {
+            return undefined;
+        }
+        var initialPropertyExtensionOptions = {};
+        var propertyExtensionMetadata = new propertyExtensionMetadataCtor(this, initialPropertyExtensionOptions);
+        return propertyExtensionMetadata;
+    };
+    PropertyMetadata.prototype.extractPropertyExtensionMetadataCtorSet = function () {
+        var customValueMap = this.propertyOptions.customValueMap;
+        if (customValueMap === undefined) {
+            customValueMap = new Map();
+            this.propertyOptions.customValueMap = customValueMap;
+        }
+        var propertyExtensionMetadataCtorSet = customValueMap.get(PROPERTY_EXTENSION_METADATA_CTOR_SET_KEY);
+        if (propertyExtensionMetadataCtorSet === undefined) {
+            propertyExtensionMetadataCtorSet = new Set();
+            customValueMap.set(PROPERTY_EXTENSION_METADATA_CTOR_SET_KEY, propertyExtensionMetadataCtorSet);
+        }
+        return propertyExtensionMetadataCtorSet;
+    };
+    PropertyMetadata.prototype.resolvePropertyState = function () {
+        var propertyOptions = this.propertyOptions;
+        var propertyName = this.propertyName;
+        var alias = propertyOptions.alias;
+        var deserializedPropertyName = propertyName;
+        var typeArgument = propertyOptions.typeArgument === undefined
+            ? this.reflectTypeFn
+            : propertyOptions.typeArgument;
+        var typeMetadata = this.resolveTypeMetadata(typeArgument);
+        var typeState = typeMetadata.typeState;
+        var customValueMap = this.resolveCustomValueMap(typeState);
+        var preserveNull = propertyOptions.preserveNull === undefined
+            ? typeState.preserveNull
+            : propertyOptions.preserveNull;
+        var useDefaultValue = propertyOptions.useDefaultValue === undefined
+            ? typeState.useDefaultValue
+            : propertyOptions.useDefaultValue;
+        var useImplicitConversion = propertyOptions.useImplicitConversion === undefined
+            ? typeState.useImplicitConversion
+            : propertyOptions.useImplicitConversion;
+        var serializedDefaultValue = propertyOptions.defaultValue === undefined
+            ? (propertyOptions.serializedDefaultValue === undefined ? typeState.serializedDefaultValue : propertyOptions.serializedDefaultValue)
+            : propertyOptions.defaultValue;
+        var serializedDefaultValueResolver = useDefaultValue
+            ? (typeof serializedDefaultValue === 'function' ? serializedDefaultValue : function () { return serializedDefaultValue; })
+            : DEFAULT_VALUE_RESOLVER;
+        var serializedNullValueResolver = preserveNull
+            ? NULL_VALUE_RESOLVER
+            : serializedDefaultValueResolver;
+        var deserializedDefaultValue = propertyOptions.defaultValue === undefined
+            ? (propertyOptions.deserializedDefaultValue === undefined ? typeState.deserializedDefaultValue : propertyOptions.deserializedDefaultValue)
+            : propertyOptions.defaultValue;
+        var deserializedDefaultValueResolver = useDefaultValue
+            ? (typeof deserializedDefaultValue === 'function' ? deserializedDefaultValue : function () { return deserializedDefaultValue; })
+            : DEFAULT_VALUE_RESOLVER;
+        var deserializedNullValueResolver = preserveNull
+            ? NULL_VALUE_RESOLVER
+            : deserializedDefaultValueResolver;
+        var namingConvention = propertyOptions.namingConvention === undefined
+            ? this.declaringTypeMetadata.typeState.namingConvention
+            : propertyOptions.namingConvention;
+        var serializedPropertyName = alias === undefined
+            ? (namingConvention === undefined ? propertyName : namingConvention.convert(propertyName))
+            : alias;
+        var useDefaultSerialization = propertyOptions.serializable === undefined
+            && propertyOptions.deserializable === undefined;
+        var serializable = useDefaultSerialization
+            || propertyOptions.serializable === true;
+        var deserializable = useDefaultSerialization
+            || propertyOptions.deserializable === true;
+        var genericArguments = propertyOptions.genericArguments === undefined
+            ? EMPTY_ARRAY
+            : propertyOptions.genericArguments;
+        var genericMetadatas = this.resolveGenericMetadatas(genericArguments);
+        var referenceHandler = propertyOptions.referenceHandler === undefined
+            ? typeState.referenceHandler
+            : propertyOptions.referenceHandler;
+        var serializer = propertyOptions.serializer === undefined
+            ? typeState.serializer
+            : propertyOptions.serializer;
+        var resolvedPropertyState = new ResolvedPropertyState(this, alias, customValueMap, serializedNullValueResolver, serializedDefaultValueResolver, deserializedNullValueResolver, deserializedDefaultValueResolver, serializedPropertyName, deserializedPropertyName, serializable, deserializable, genericArguments, genericMetadatas, namingConvention, referenceHandler, serializer, typeArgument, typeMetadata, preserveNull, useDefaultValue, useImplicitConversion);
+        this.currentPropertyState = resolvedPropertyState;
+        return resolvedPropertyState;
+    };
+    PropertyMetadata.prototype.unresolvePropertyState = function () {
+        var unresolvedPropertyState = new UnresolvedPropertyState(this);
+        this.currentPropertyState = unresolvedPropertyState;
+        return unresolvedPropertyState;
+    };
+    PropertyMetadata.prototype.resolveCustomValueMap = function (typeState) {
+        var e_1, _a;
+        var propertyOptions = this.propertyOptions;
+        var customValueMap = new Map();
+        if (propertyOptions.customValueMap === undefined) {
+            return customValueMap;
+        }
+        var typeCustomValueMap = typeState.customValueMap === undefined
+            ? EMPTY_MAP
+            : typeState.customValueMap;
+        try {
+            for (var _b = __values(propertyOptions.customValueMap), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var _d = __read(_c.value, 2), customKey = _d[0], customValue = _d[1];
+                if (customValue === undefined) {
+                    customValueMap.set(customKey, typeCustomValueMap.get(customKey));
+                    continue;
+                }
+                customValueMap.set(customKey, customValue);
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        return customValueMap;
     };
     PropertyMetadata.prototype.hasAlias = function (alias) {
         this.propertyOptions.alias = alias;
+        this.currentPropertyState = new UnresolvedPropertyState(this);
+        return this;
+    };
+    PropertyMetadata.prototype.hasCustomValueMap = function (customValueMap) {
+        var e_2, _a;
+        var currentCustomValueMap = this.propertyOptions.customValueMap;
+        if (currentCustomValueMap === undefined) {
+            currentCustomValueMap = new Map();
+            this.propertyOptions.customValueMap = currentCustomValueMap;
+        }
+        if (customValueMap !== undefined) {
+            if (currentCustomValueMap !== customValueMap) {
+                currentCustomValueMap.clear();
+            }
+            try {
+                for (var customValueMap_1 = __values(customValueMap), customValueMap_1_1 = customValueMap_1.next(); !customValueMap_1_1.done; customValueMap_1_1 = customValueMap_1.next()) {
+                    var _b = __read(customValueMap_1_1.value, 2), customKey = _b[0], customValue = _b[1];
+                    currentCustomValueMap.set(customKey, customValue);
+                }
+            }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            finally {
+                try {
+                    if (customValueMap_1_1 && !customValueMap_1_1.done && (_a = customValueMap_1.return)) _a.call(customValueMap_1);
+                }
+                finally { if (e_2) throw e_2.error; }
+            }
+        }
+        this.currentPropertyState = new UnresolvedPropertyState(this);
         return this;
     };
-    PropertyMetadata.prototype.hasCustomOption = function (customKey, customValue) {
-        this.customContext.set(customKey, customValue);
+    PropertyMetadata.prototype.hasCustomValue = function (customKey, customValue) {
+        var customValueMap = this.propertyOptions.customValueMap;
+        if (customValueMap === undefined) {
+            customValueMap = new Map();
+            this.propertyOptions.customValueMap = customValueMap;
+        }
+        customValueMap.set(customKey, customValue);
+        this.currentPropertyState = new UnresolvedPropertyState(this);
         return this;
     };
-    PropertyMetadata.prototype.extractCustomOption = function (customKey) {
-        return this.customContext.get(customKey);
+    PropertyMetadata.prototype.extractCustomValue = function (customKey) {
+        var customValue = this.propertyState.customValueMap.get(customKey);
+        if (customValue === undefined && customKey.customValueResolver !== undefined) {
+            customValue = customKey.customValueResolver();
+        }
+        return customValue;
     };
     PropertyMetadata.prototype.hasCustomOptions = function (customOptions) {
-        if (!isNil(customOptions)) {
-            this.customContext.configure(customOptions);
+        var customValueMap = this.propertyOptions.customValueMap;
+        if (customValueMap === undefined) {
+            customValueMap = new Map();
+            this.propertyOptions.customValueMap = customValueMap;
+        }
+        for (var i = 0; i < customOptions.length; i++) {
+            customValueMap.set(customOptions[i][0], customOptions[i][1]);
         }
+        this.currentPropertyState = new UnresolvedPropertyState(this);
         return this;
     };
     PropertyMetadata.prototype.hasDefaultValue = function (defaultValue) {
         this.propertyOptions.defaultValue = defaultValue;
+        this.currentPropertyState = new UnresolvedPropertyState(this);
         return this;
     };
     PropertyMetadata.prototype.hasSerializedDefaultValue = function (serializedDefaultValue) {
         this.propertyOptions.serializedDefaultValue = serializedDefaultValue;
+        this.currentPropertyState = new UnresolvedPropertyState(this);
         return this;
     };
     PropertyMetadata.prototype.hasDeserializedDefaultValue = function (deserializedDefaultValue) {
         this.propertyOptions.deserializedDefaultValue = deserializedDefaultValue;
+        this.currentPropertyState = new UnresolvedPropertyState(this);
         return this;
     };
     PropertyMetadata.prototype.isDeserializable = function (deserializable) {
         if (deserializable === void 0) { deserializable = true; }
         this.propertyOptions.deserializable = deserializable;
+        this.currentPropertyState = new UnresolvedPropertyState(this);
         return this;
     };
     PropertyMetadata.prototype.isSerializable = function (serializable) {
         if (serializable === void 0) { serializable = true; }
         this.propertyOptions.serializable = serializable;
+        this.currentPropertyState = new UnresolvedPropertyState(this);
         return this;
     };
     PropertyMetadata.prototype.hasGenericArguments = function (genericArguments) {
         this.propertyOptions.genericArguments = genericArguments;
-        if (isNil(genericArguments)) {
-            this.propertyInternals.genericStructures = undefined;
-            this.propertyInternals.genericMetadataResolvers = undefined;
-            return this;
-        }
-        var genericStructures = this.defineGenericStructures(genericArguments);
-        this.propertyInternals.genericStructures = genericStructures;
-        this.propertyInternals.genericMetadataResolvers = this.defineGenericMetadataResolvers(genericStructures);
+        this.currentPropertyState = new UnresolvedPropertyState(this);
         return this;
     };
     PropertyMetadata.prototype.hasNamingConvention = function (namingConvention) {
         this.propertyOptions.namingConvention = namingConvention;
+        this.currentPropertyState = new UnresolvedPropertyState(this);
         return this;
     };
     PropertyMetadata.prototype.hasReferenceHandler = function (referenceHandler) {
         this.propertyOptions.referenceHandler = referenceHandler;
+        this.currentPropertyState = new UnresolvedPropertyState(this);
         return this;
     };
     PropertyMetadata.prototype.hasSerializer = function (serializer) {
         this.propertyOptions.serializer = serializer;
+        this.currentPropertyState = new UnresolvedPropertyState(this);
         return this;
     };
     PropertyMetadata.prototype.hasTypeArgument = function (typeArgument) {
         this.propertyOptions.typeArgument = typeArgument !== null && typeArgument !== void 0 ? typeArgument : this.reflectTypeFn;
-        this.propertyInternals.typeMetadataResolver = this.defineTypeMetadataResolver(this.propertyOptions.typeArgument);
+        this.currentPropertyState = new UnresolvedPropertyState(this);
         return this;
     };
     PropertyMetadata.prototype.shouldPreserveNull = function (preserveNull) {
         if (preserveNull === void 0) { preserveNull = true; }
         this.propertyOptions.preserveNull = preserveNull;
+        this.currentPropertyState = new UnresolvedPropertyState(this);
         return this;
     };
     PropertyMetadata.prototype.shouldUseDefaultValue = function (useDefaultValue) {
         if (useDefaultValue === void 0) { useDefaultValue = true; }
         this.propertyOptions.useDefaultValue = useDefaultValue;
+        this.currentPropertyState = new UnresolvedPropertyState(this);
         return this;
     };
     PropertyMetadata.prototype.shouldUseImplicitConversion = function (useImplicitConversion) {
         if (useImplicitConversion === void 0) { useImplicitConversion = true; }
         this.propertyOptions.useImplicitConversion = useImplicitConversion;
+        this.currentPropertyState = new UnresolvedPropertyState(this);
         return this;
     };
-    PropertyMetadata.prototype.configurePropertyExtensionMetadata = function (propertyExtensionMetadataCtor, propertyExtensionOptions) {
-        var propertyExtensionMetadataCtorSet = this.extractCustomOption(propertyExtensionMetadataCtorSetKey);
-        if (!propertyExtensionMetadataCtorSet.has(propertyExtensionMetadataCtor)) {
-            propertyExtensionMetadataCtorSet.add(propertyExtensionMetadataCtor);
-        }
-        var initialPropertyExtensionOptions = propertyExtensionOptions !== null && propertyExtensionOptions !== void 0 ? propertyExtensionOptions : {};
-        var propertyExtensionMetadata = new propertyExtensionMetadataCtor(this, initialPropertyExtensionOptions);
-        return propertyExtensionMetadata;
-    };
-    PropertyMetadata.prototype.extractPropertyExtensionMetadata = function (propertyExtensionMetadataCtor) {
-        var propertyExtensionMetadataCtorSet = this.extractCustomOption(propertyExtensionMetadataCtorSetKey);
-        if (!propertyExtensionMetadataCtorSet.has(propertyExtensionMetadataCtor)) {
-            return undefined;
-        }
-        var initialPropertyExtensionOptions = {};
-        var propertyExtensionMetadata = new propertyExtensionMetadataCtor(this, initialPropertyExtensionOptions);
-        return propertyExtensionMetadata;
-    };
     PropertyMetadata.prototype.configure = function (propertyOptions) {
-        if (!isUndefined(propertyOptions.alias)) {
+        if (propertyOptions.alias !== undefined) {
             this.hasAlias(propertyOptions.alias);
         }
-        if (!isUndefined(propertyOptions.customOptions)) {
-            this.hasCustomOptions(propertyOptions.customOptions);
+        if (propertyOptions.customValueMap !== undefined) {
+            this.hasCustomValueMap(propertyOptions.customValueMap);
         }
-        if (!isUndefined(propertyOptions.defaultValue)) {
+        if (propertyOptions.defaultValue !== undefined) {
             this.hasDefaultValue(propertyOptions.defaultValue);
         }
-        if (!isUndefined(propertyOptions.serializedDefaultValue)) {
+        if (propertyOptions.serializedDefaultValue !== undefined) {
             this.hasSerializedDefaultValue(propertyOptions.serializedDefaultValue);
         }
-        if (!isUndefined(propertyOptions.deserializedDefaultValue)) {
+        if (propertyOptions.deserializedDefaultValue !== undefined) {
             this.hasDeserializedDefaultValue(propertyOptions.deserializedDefaultValue);
         }
-        if (!isUndefined(propertyOptions.deserializable)) {
+        if (propertyOptions.deserializable !== undefined) {
             this.isDeserializable(propertyOptions.deserializable);
         }
-        if (!isUndefined(propertyOptions.genericArguments)) {
+        if (propertyOptions.genericArguments !== undefined) {
             this.hasGenericArguments(propertyOptions.genericArguments);
         }
-        if (!isUndefined(propertyOptions.namingConvention)) {
+        if (propertyOptions.namingConvention !== undefined) {
             this.hasNamingConvention(propertyOptions.namingConvention);
         }
-        if (!isUndefined(propertyOptions.referenceHandler)) {
+        if (propertyOptions.referenceHandler !== undefined) {
             this.hasReferenceHandler(propertyOptions.referenceHandler);
         }
-        if (!isUndefined(propertyOptions.serializable)) {
+        if (propertyOptions.serializable !== undefined) {
             this.isSerializable(propertyOptions.serializable);
         }
-        if (!isUndefined(propertyOptions.serializer)) {
+        if (propertyOptions.serializer !== undefined) {
             this.hasSerializer(propertyOptions.serializer);
         }
-        if (!isUndefined(propertyOptions.typeArgument)) {
+        if (propertyOptions.typeArgument !== undefined) {
             this.hasTypeArgument(propertyOptions.typeArgument);
         }
-        if (!isUndefined(propertyOptions.preserveNull)) {
+        if (propertyOptions.preserveNull !== undefined) {
             this.shouldPreserveNull(propertyOptions.preserveNull);
         }
-        if (!isUndefined(propertyOptions.useDefaultValue)) {
+        if (propertyOptions.useDefaultValue !== undefined) {
             this.shouldUseDefaultValue(propertyOptions.useDefaultValue);
         }
-        if (!isUndefined(propertyOptions.useImplicitConversion)) {
+        if (propertyOptions.useImplicitConversion !== undefined) {
             this.shouldUseImplicitConversion(propertyOptions.useImplicitConversion);
         }
         return this;