@dipscope/type-manager
Version:
Transform JSON strings or plain objects into JS class instances.
615 lines • 32.1 kB
JavaScript
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 { Any } from './any';
import { EMPTY_ARRAY } from './constants/empty-array';
import { TypeFactory } from './factories/type-factory';
import { jsonParse } from './functions/json-parse';
import { jsonStringify } from './functions/json-stringify';
import { SingletonInjector } from './injectors/singleton-injector';
import { Logger } from './logger';
import { LoggerLevel } from './logger-level';
import { CircularReferenceHandler } from './reference-handlers/circular-reference-handler';
import { SerializerContext } from './serializer-context';
import { AnySerializer } from './serializers/any-serializer';
import { ArrayBufferSerializer } from './serializers/array-buffer-serializer';
import { ArraySerializer } from './serializers/array-serializer';
import { BooleanSerializer } from './serializers/boolean-serializer';
import { DataViewSerializer } from './serializers/data-view-serializer';
import { DateSerializer } from './serializers/date-serializer';
import { Float32ArraySerializer } from './serializers/float-32-array-serializer';
import { Float64ArraySerializer } from './serializers/float-64-array-serializer';
import { Int16ArraySerializer } from './serializers/int-16-array-serializer';
import { Int32ArraySerializer } from './serializers/int-32-array-serializer';
import { Int8ArraySerializer } from './serializers/int-8-array-serializer';
import { MapSerializer } from './serializers/map-serializer';
import { NumberSerializer } from './serializers/number-serializer';
import { SetSerializer } from './serializers/set-serializer';
import { StringSerializer } from './serializers/string-serializer';
import { TypeSerializer } from './serializers/type-serializer';
import { Uint16ArraySerializer } from './serializers/uint-16-array-serializer';
import { Uint32ArraySerializer } from './serializers/uint-32-array-serializer';
import { Uint8ArraySerializer } from './serializers/uint-8-array-serializer';
import { Uint8ClampedArraySerializer } from './serializers/uint-8-clamped-array-serializer';
import { UnknownSerializer } from './serializers/unknown-serializer';
import { TypeMetadata } from './type-metadata';
import { TYPE_METADATA_SYMBOL } from './type-metadata-symbol';
import { TypeScope } from './type-scope';
import { Unknown } from './unknown';
var TypeManager = (function () {
function TypeManager(typeManagerOptions) {
if (typeManagerOptions === void 0) { typeManagerOptions = {}; }
this.symbol = Symbol(TYPE_METADATA_SYMBOL.description);
this.typeManagerOptions = this.constructTypeManagerOptions(typeManagerOptions);
this.typeFnMap = new Map();
this.typeMetadataSet = new Set();
this.configure(typeManagerOptions);
return;
}
Object.defineProperty(TypeManager, "symbol", {
get: function () {
return this.staticTypeManager.symbol;
},
enumerable: false,
configurable: true
});
Object.defineProperty(TypeManager, "logger", {
get: function () {
return this.staticTypeManager.logger;
},
enumerable: false,
configurable: true
});
Object.defineProperty(TypeManager.prototype, "logger", {
get: function () {
return this.typeOptionsBase.logger;
},
enumerable: false,
configurable: true
});
Object.defineProperty(TypeManager, "typeOptionsBase", {
get: function () {
return this.staticTypeManager.typeOptionsBase;
},
enumerable: false,
configurable: true
});
Object.defineProperty(TypeManager.prototype, "typeOptionsBase", {
get: function () {
var typeOptionsBase = this.typeManagerOptions.typeOptionsBase;
if (typeOptionsBase === undefined) {
typeOptionsBase = {};
this.typeManagerOptions.typeOptionsBase = this.constructTypeOptionsBase(typeOptionsBase);
}
return typeOptionsBase;
},
enumerable: false,
configurable: true
});
Object.defineProperty(TypeManager, "typeOptionsMap", {
get: function () {
return this.staticTypeManager.typeOptionsMap;
},
enumerable: false,
configurable: true
});
Object.defineProperty(TypeManager.prototype, "typeOptionsMap", {
get: function () {
var typeOptionsMap = this.typeManagerOptions.typeOptionsMap;
if (typeOptionsMap === undefined) {
typeOptionsMap = new Map();
this.typeManagerOptions.typeOptionsMap = this.constructTypeOptionsMap(typeOptionsMap);
}
return typeOptionsMap;
},
enumerable: false,
configurable: true
});
Object.defineProperty(TypeManager, "typeConfigurationMap", {
get: function () {
return this.staticTypeManager.typeConfigurationMap;
},
enumerable: false,
configurable: true
});
Object.defineProperty(TypeManager.prototype, "typeConfigurationMap", {
get: function () {
var typeConfigurationMap = this.typeManagerOptions.typeConfigurationMap;
if (typeConfigurationMap === undefined) {
typeConfigurationMap = new Map();
this.typeManagerOptions.typeConfigurationMap = typeConfigurationMap;
}
return typeConfigurationMap;
},
enumerable: false,
configurable: true
});
TypeManager.prototype.constructTypeManagerOptions = function (typeManagerOptions) {
var typeOptionsBase = typeManagerOptions.typeOptionsBase;
if (typeOptionsBase === undefined) {
typeOptionsBase = {};
typeManagerOptions.typeOptionsBase = this.constructTypeOptionsBase(typeOptionsBase);
}
var typeOptionsMap = typeManagerOptions.typeOptionsMap;
if (typeOptionsMap === undefined) {
typeOptionsMap = new Map();
typeManagerOptions.typeOptionsMap = this.constructTypeOptionsMap(typeOptionsMap);
}
return typeManagerOptions;
};
TypeManager.prototype.constructTypeOptionsBase = function (typeOptionsBase) {
var customValueMap = new Map();
var initialTypeOptionsBase = Object.assign({}, TypeManager.defaultTypeOptionsBase, { customValueMap: customValueMap }, typeOptionsBase);
Object.assign(typeOptionsBase, initialTypeOptionsBase);
return typeOptionsBase;
};
TypeManager.prototype.constructTypeOptionsMap = function (typeOptionsMap) {
var e_1, _a, e_2, _b, e_3, _c;
var initialTypeOptionsMap = new Map();
try {
for (var _d = __values(TypeManager.defaultTypeOptionsMap), _e = _d.next(); !_e.done; _e = _d.next()) {
var _f = __read(_e.value, 2), typeFn = _f[0], typeOptions = _f[1];
var mapTypeOptions = initialTypeOptionsMap.get(typeFn);
if (mapTypeOptions === undefined) {
mapTypeOptions = {};
}
initialTypeOptionsMap.set(typeFn, Object.assign(mapTypeOptions, typeOptions));
}
}
catch (e_1_1) { e_1 = { error: e_1_1 }; }
finally {
try {
if (_e && !_e.done && (_a = _d.return)) _a.call(_d);
}
finally { if (e_1) throw e_1.error; }
}
try {
for (var typeOptionsMap_1 = __values(typeOptionsMap), typeOptionsMap_1_1 = typeOptionsMap_1.next(); !typeOptionsMap_1_1.done; typeOptionsMap_1_1 = typeOptionsMap_1.next()) {
var _g = __read(typeOptionsMap_1_1.value, 2), typeFn = _g[0], typeOptions = _g[1];
var mapTypeOptions = initialTypeOptionsMap.get(typeFn);
if (mapTypeOptions === undefined) {
mapTypeOptions = {};
}
initialTypeOptionsMap.set(typeFn, Object.assign(typeOptions, Object.assign(mapTypeOptions, typeOptions)));
}
}
catch (e_2_1) { e_2 = { error: e_2_1 }; }
finally {
try {
if (typeOptionsMap_1_1 && !typeOptionsMap_1_1.done && (_b = typeOptionsMap_1.return)) _b.call(typeOptionsMap_1);
}
finally { if (e_2) throw e_2.error; }
}
typeOptionsMap.clear();
try {
for (var initialTypeOptionsMap_1 = __values(initialTypeOptionsMap), initialTypeOptionsMap_1_1 = initialTypeOptionsMap_1.next(); !initialTypeOptionsMap_1_1.done; initialTypeOptionsMap_1_1 = initialTypeOptionsMap_1.next()) {
var _h = __read(initialTypeOptionsMap_1_1.value, 2), typeFn = _h[0], typeOptions = _h[1];
typeOptionsMap.set(typeFn, typeOptions);
}
}
catch (e_3_1) { e_3 = { error: e_3_1 }; }
finally {
try {
if (initialTypeOptionsMap_1_1 && !initialTypeOptionsMap_1_1.done && (_c = initialTypeOptionsMap_1.return)) _c.call(initialTypeOptionsMap_1);
}
finally { if (e_3) throw e_3.error; }
}
return typeOptionsMap;
};
TypeManager.configureTypeMetadata = function (typeFn, typeOptions) {
return this.staticTypeManager.configureTypeMetadata(typeFn, typeOptions);
};
TypeManager.prototype.configureTypeMetadata = function (typeFn, typeOptions) {
var symbol = this.symbol;
var prototype = typeFn.prototype;
var typeMetadataDefined = prototype.hasOwnProperty(symbol);
var typeMetadata = typeMetadataDefined ? prototype[symbol] : this.declareTypeMetadata(typeFn, typeOptions);
if (!typeMetadataDefined) {
Object.defineProperty(prototype, symbol, {
enumerable: false,
configurable: true,
writable: false,
value: typeMetadata
});
}
if (typeMetadataDefined && typeOptions !== undefined) {
typeMetadata.configure(typeOptions);
}
return typeMetadata;
};
TypeManager.prototype.declareTypeMetadata = function (typeFn, typeOptions) {
var _a;
var typeOptionsMap = this.typeManagerOptions.typeOptionsMap;
if (typeOptionsMap === undefined) {
typeOptionsMap = new Map();
this.typeManagerOptions.typeOptionsMap = this.constructTypeOptionsMap(typeOptionsMap);
}
var mapTypeOptions = typeOptionsMap.get(typeFn);
if (mapTypeOptions === undefined) {
mapTypeOptions = typeOptions !== null && typeOptions !== void 0 ? typeOptions : {};
typeOptionsMap.set(typeFn, mapTypeOptions);
}
var typeFnMap = this.typeFnMap;
var typeMetadataSet = this.typeMetadataSet;
var symbol = this.symbol;
var parentPrototype = (_a = Object.getPrototypeOf(typeFn.prototype)) !== null && _a !== void 0 ? _a : {};
var parentTypeMetadata = parentPrototype[symbol];
var typeMetadata = new TypeMetadata(this, typeFnMap, typeMetadataSet, typeFn, mapTypeOptions, parentTypeMetadata);
typeMetadataSet.add(typeMetadata);
return typeMetadata;
};
TypeManager.extractTypeMetadata = function (typeFn) {
return this.staticTypeManager.extractTypeMetadata(typeFn);
};
TypeManager.prototype.extractTypeMetadata = function (typeFn) {
var symbol = this.symbol;
var prototype = typeFn.prototype;
var typeMetadataDefined = prototype.hasOwnProperty(symbol);
var typeMetadata = typeMetadataDefined ? prototype[symbol] : this.configureTypeMetadata(typeFn);
return typeMetadata;
};
TypeManager.applyTypeOptionsBase = function (typeOptionsBase) {
return this.staticTypeManager.applyTypeOptionsBase(typeOptionsBase);
};
TypeManager.prototype.applyTypeOptionsBase = function (typeOptionsBase) {
var e_4, _a, e_5, _b;
var customValueMap = this.typeOptionsBase.customValueMap;
Object.assign(this.typeOptionsBase, typeOptionsBase, { customValueMap: customValueMap });
if (typeOptionsBase.customValueMap !== undefined) {
try {
for (var _c = __values(typeOptionsBase.customValueMap), _d = _c.next(); !_d.done; _d = _c.next()) {
var _e = __read(_d.value, 2), customKey = _e[0], customValue = _e[1];
customValueMap.set(customKey, customValue);
}
}
catch (e_4_1) { e_4 = { error: e_4_1 }; }
finally {
try {
if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
}
finally { if (e_4) throw e_4.error; }
}
}
try {
for (var _f = __values(this.typeMetadataSet), _g = _f.next(); !_g.done; _g = _f.next()) {
var typeMetadata = _g.value;
typeMetadata.unresolveTypeState();
}
}
catch (e_5_1) { e_5 = { error: e_5_1 }; }
finally {
try {
if (_g && !_g.done && (_b = _f.return)) _b.call(_f);
}
finally { if (e_5) throw e_5.error; }
}
return this;
};
TypeManager.applyTypeOptionsMap = function (typeOptionsMap) {
return this.staticTypeManager.applyTypeOptionsMap(typeOptionsMap);
};
TypeManager.prototype.applyTypeOptionsMap = function (typeOptionsMap) {
var e_6, _a;
try {
for (var typeOptionsMap_2 = __values(typeOptionsMap), typeOptionsMap_2_1 = typeOptionsMap_2.next(); !typeOptionsMap_2_1.done; typeOptionsMap_2_1 = typeOptionsMap_2.next()) {
var _b = __read(typeOptionsMap_2_1.value, 2), typeFn = _b[0], typeOptions = _b[1];
this.applyTypeOptions(typeFn, typeOptions);
}
}
catch (e_6_1) { e_6 = { error: e_6_1 }; }
finally {
try {
if (typeOptionsMap_2_1 && !typeOptionsMap_2_1.done && (_a = typeOptionsMap_2.return)) _a.call(typeOptionsMap_2);
}
finally { if (e_6) throw e_6.error; }
}
return this;
};
TypeManager.applyTypeOptions = function (typeFn, typeOptions) {
return this.staticTypeManager.applyTypeOptions(typeFn, typeOptions);
};
TypeManager.prototype.applyTypeOptions = function (typeFn, typeOptions) {
var typeMetadata = this.extractTypeMetadata(typeFn);
typeMetadata.configure(typeOptions);
return this;
};
TypeManager.applyTypeConfigurationMap = function (typeConfigurationMap) {
return this.staticTypeManager.applyTypeConfigurationMap(typeConfigurationMap);
};
TypeManager.prototype.applyTypeConfigurationMap = function (typeConfigurationMap) {
var e_7, _a;
try {
for (var typeConfigurationMap_1 = __values(typeConfigurationMap), typeConfigurationMap_1_1 = typeConfigurationMap_1.next(); !typeConfigurationMap_1_1.done; typeConfigurationMap_1_1 = typeConfigurationMap_1.next()) {
var _b = __read(typeConfigurationMap_1_1.value, 2), typeFn = _b[0], typeConfiguration = _b[1];
this.applyTypeConfiguration(typeFn, typeConfiguration);
}
}
catch (e_7_1) { e_7 = { error: e_7_1 }; }
finally {
try {
if (typeConfigurationMap_1_1 && !typeConfigurationMap_1_1.done && (_a = typeConfigurationMap_1.return)) _a.call(typeConfigurationMap_1);
}
finally { if (e_7) throw e_7.error; }
}
return this;
};
TypeManager.applyTypeConfiguration = function (typeFn, typeConfiguration) {
return this.staticTypeManager.applyTypeConfiguration(typeFn, typeConfiguration);
};
TypeManager.prototype.applyTypeConfiguration = function (typeFn, typeConfiguration) {
var typeMetadata = this.extractTypeMetadata(typeFn);
typeConfiguration.configure(typeMetadata);
return this;
};
TypeManager.configure = function (typeManagerOptions) {
return this.staticTypeManager.configure(typeManagerOptions);
};
TypeManager.prototype.configure = function (typeManagerOptions) {
if (typeManagerOptions.typeOptionsBase !== undefined) {
this.applyTypeOptionsBase(typeManagerOptions.typeOptionsBase);
}
if (typeManagerOptions.typeOptionsMap !== undefined) {
this.applyTypeOptionsMap(typeManagerOptions.typeOptionsMap);
}
if (typeManagerOptions.typeConfigurationMap !== undefined) {
this.applyTypeConfigurationMap(typeManagerOptions.typeConfigurationMap);
}
return this;
};
TypeManager.defineSerializerContext = function (typeFn, x, genericArguments) {
return this.staticTypeManager.defineSerializerContext(typeFn, x, genericArguments);
};
TypeManager.prototype.defineSerializerContext = function (typeFn, x, genericArguments) {
var typeMetadata = this.extractTypeMetadata(typeFn);
var genericMetadatas = genericArguments === undefined ? EMPTY_ARRAY : typeMetadata.resolveGenericMetadatas(genericArguments);
return new SerializerContext(x, new Map(), new Map(), undefined, '$', typeMetadata.typeState, genericMetadatas, undefined, undefined);
};
TypeManager.clone = function () {
return this.staticTypeManager.clone();
};
TypeManager.prototype.clone = function () {
var typeOptionsBase = this.cloneTypeOptionsBase();
var typeOptionsMap = this.cloneTypeOptionsMap();
var typeManagerOptions = { typeOptionsBase: typeOptionsBase, typeOptionsMap: typeOptionsMap };
var typeManager = new TypeManager(typeManagerOptions);
return typeManager;
};
TypeManager.prototype.cloneTypeOptionsBase = function () {
var e_8, _a;
var typeOptionsBase = this.typeOptionsBase;
var customValueMap = typeOptionsBase.customValueMap;
var customValueMapClone = new Map();
var typeOptionsBaseClone = Object.assign({}, typeOptionsBase, { customValueMap: customValueMapClone });
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];
customValueMapClone.set(customKey, customValue);
}
}
catch (e_8_1) { e_8 = { error: e_8_1 }; }
finally {
try {
if (customValueMap_1_1 && !customValueMap_1_1.done && (_a = customValueMap_1.return)) _a.call(customValueMap_1);
}
finally { if (e_8) throw e_8.error; }
}
return typeOptionsBaseClone;
};
TypeManager.prototype.cloneTypeOptionsMap = function () {
var e_9, _a, e_10, _b, e_11, _c, e_12, _d, e_13, _e;
var typeOptionsMap = this.typeOptionsMap;
var typeOptionsMapClone = new Map();
try {
for (var typeOptionsMap_3 = __values(typeOptionsMap), typeOptionsMap_3_1 = typeOptionsMap_3.next(); !typeOptionsMap_3_1.done; typeOptionsMap_3_1 = typeOptionsMap_3.next()) {
var _f = __read(typeOptionsMap_3_1.value, 2), typeFn = _f[0], typeOptions = _f[1];
var typeOptionsClone = Object.assign({}, typeOptions);
var typeCustomValueMap = typeOptions.customValueMap;
if (typeCustomValueMap !== undefined) {
var typeCustomValueMapClone = new Map();
try {
for (var typeCustomValueMap_1 = (e_10 = void 0, __values(typeCustomValueMap)), typeCustomValueMap_1_1 = typeCustomValueMap_1.next(); !typeCustomValueMap_1_1.done; typeCustomValueMap_1_1 = typeCustomValueMap_1.next()) {
var _g = __read(typeCustomValueMap_1_1.value, 2), customKey = _g[0], customValue = _g[1];
typeCustomValueMapClone.set(customKey, customValue);
}
}
catch (e_10_1) { e_10 = { error: e_10_1 }; }
finally {
try {
if (typeCustomValueMap_1_1 && !typeCustomValueMap_1_1.done && (_b = typeCustomValueMap_1.return)) _b.call(typeCustomValueMap_1);
}
finally { if (e_10) throw e_10.error; }
}
typeOptionsClone.customValueMap = typeCustomValueMapClone;
}
var propertyOptionsMap = typeOptions.propertyOptionsMap;
if (propertyOptionsMap !== undefined) {
var propertyOptionsMapClone = new Map();
try {
for (var propertyOptionsMap_1 = (e_11 = void 0, __values(propertyOptionsMap)), propertyOptionsMap_1_1 = propertyOptionsMap_1.next(); !propertyOptionsMap_1_1.done; propertyOptionsMap_1_1 = propertyOptionsMap_1.next()) {
var _h = __read(propertyOptionsMap_1_1.value, 2), propertyName = _h[0], propertyOptions = _h[1];
var propertyOptionsClone = Object.assign({}, propertyOptions);
var propertyCustomValueMap = propertyOptions.customValueMap;
if (propertyCustomValueMap !== undefined) {
var propertyCustomValueMapClone = new Map();
try {
for (var propertyCustomValueMap_1 = (e_12 = void 0, __values(propertyCustomValueMap)), propertyCustomValueMap_1_1 = propertyCustomValueMap_1.next(); !propertyCustomValueMap_1_1.done; propertyCustomValueMap_1_1 = propertyCustomValueMap_1.next()) {
var _j = __read(propertyCustomValueMap_1_1.value, 2), customKey = _j[0], customValue = _j[1];
propertyCustomValueMapClone.set(customKey, customValue);
}
}
catch (e_12_1) { e_12 = { error: e_12_1 }; }
finally {
try {
if (propertyCustomValueMap_1_1 && !propertyCustomValueMap_1_1.done && (_d = propertyCustomValueMap_1.return)) _d.call(propertyCustomValueMap_1);
}
finally { if (e_12) throw e_12.error; }
}
propertyOptionsClone.customValueMap = propertyCustomValueMapClone;
}
propertyOptionsMapClone.set(propertyName, propertyOptionsClone);
}
}
catch (e_11_1) { e_11 = { error: e_11_1 }; }
finally {
try {
if (propertyOptionsMap_1_1 && !propertyOptionsMap_1_1.done && (_c = propertyOptionsMap_1.return)) _c.call(propertyOptionsMap_1);
}
finally { if (e_11) throw e_11.error; }
}
typeOptionsClone.propertyOptionsMap = propertyOptionsMapClone;
}
var injectOptionsMap = typeOptions.injectOptionsMap;
if (injectOptionsMap !== undefined) {
var injectOptionsMapClone = new Map();
try {
for (var injectOptionsMap_1 = (e_13 = void 0, __values(injectOptionsMap)), injectOptionsMap_1_1 = injectOptionsMap_1.next(); !injectOptionsMap_1_1.done; injectOptionsMap_1_1 = injectOptionsMap_1.next()) {
var _k = __read(injectOptionsMap_1_1.value, 2), injectIndex = _k[0], injectOptions = _k[1];
var injectOptionsClone = Object.assign({}, injectOptions);
injectOptionsMapClone.set(injectIndex, injectOptionsClone);
}
}
catch (e_13_1) { e_13 = { error: e_13_1 }; }
finally {
try {
if (injectOptionsMap_1_1 && !injectOptionsMap_1_1.done && (_e = injectOptionsMap_1.return)) _e.call(injectOptionsMap_1);
}
finally { if (e_13) throw e_13.error; }
}
typeOptionsClone.injectOptionsMap = injectOptionsMapClone;
}
typeOptionsMapClone.set(typeFn, typeOptionsClone);
}
}
catch (e_9_1) { e_9 = { error: e_9_1 }; }
finally {
try {
if (typeOptionsMap_3_1 && !typeOptionsMap_3_1.done && (_a = typeOptionsMap_3.return)) _a.call(typeOptionsMap_3);
}
finally { if (e_9) throw e_9.error; }
}
return typeOptionsMapClone;
};
TypeManager.clear = function () {
return this.staticTypeManager.clear();
};
TypeManager.prototype.clear = function () {
var e_14, _a;
var _b;
var symbol = this.symbol;
var typeFnMap = this.typeFnMap;
var typeMetadataSet = this.typeMetadataSet;
try {
for (var typeMetadataSet_1 = __values(typeMetadataSet), typeMetadataSet_1_1 = typeMetadataSet_1.next(); !typeMetadataSet_1_1.done; typeMetadataSet_1_1 = typeMetadataSet_1.next()) {
var typeMetadata = typeMetadataSet_1_1.value;
var prototype = (_b = typeMetadata.typeFn.prototype) !== null && _b !== void 0 ? _b : {};
delete prototype[symbol];
}
}
catch (e_14_1) { e_14 = { error: e_14_1 }; }
finally {
try {
if (typeMetadataSet_1_1 && !typeMetadataSet_1_1.done && (_a = typeMetadataSet_1.return)) _a.call(typeMetadataSet_1);
}
finally { if (e_14) throw e_14.error; }
}
typeMetadataSet.clear();
typeFnMap.clear();
return this;
};
TypeManager.serialize = function (typeFn, x) {
return this.staticTypeManager.serialize(typeFn, x);
};
TypeManager.prototype.serialize = function (typeFn, x) {
var arrayFn = Array;
if (Array.isArray(x) && typeFn !== arrayFn) {
return this.defineSerializerContext(arrayFn, x, [typeFn]).serialize(x);
}
return this.defineSerializerContext(typeFn, x).serialize(x);
};
TypeManager.deserialize = function (typeFn, x) {
return this.staticTypeManager.deserialize(typeFn, x);
};
TypeManager.prototype.deserialize = function (typeFn, x) {
var arrayFn = Array;
if (Array.isArray(x) && typeFn !== arrayFn) {
return this.defineSerializerContext(arrayFn, x, [typeFn]).deserialize(x);
}
return this.defineSerializerContext(typeFn, x).deserialize(x);
};
TypeManager.stringify = function (typeFn, x, replacer, space) {
return this.staticTypeManager.stringify(typeFn, x, replacer, space);
};
TypeManager.prototype.stringify = function (typeFn, x, replacer, space) {
return jsonStringify(this.serialize(typeFn, x), replacer, space);
};
TypeManager.parse = function (typeFn, x, reviver) {
return this.staticTypeManager.parse(typeFn, x, reviver);
};
TypeManager.prototype.parse = function (typeFn, x, reviver) {
return this.deserialize(typeFn, jsonParse(x, reviver));
};
TypeManager.defaultTypeOptionsBase = {
customValueMap: new Map(),
discriminator: '$type',
factory: new TypeFactory(),
injector: new SingletonInjector(),
logger: new Logger(LoggerLevel.Error),
preserveDiscriminator: false,
referenceHandler: new CircularReferenceHandler(),
serializer: new TypeSerializer(),
preserveNull: true,
useDefaultValue: false,
useImplicitConversion: false
};
TypeManager.defaultTypeOptionsMap = new Map([
[Any, { serializer: new AnySerializer(), serializedDefaultValue: undefined, deserializedDefaultValue: undefined }],
[ArrayBuffer, { serializer: new ArrayBufferSerializer(), serializedDefaultValue: undefined, deserializedDefaultValue: undefined }],
[Array, { serializer: new ArraySerializer(), serializedDefaultValue: function () { return []; }, deserializedDefaultValue: function () { return []; } }],
[Boolean, { serializer: new BooleanSerializer(), serializedDefaultValue: false, deserializedDefaultValue: false }],
[DataView, { serializer: new DataViewSerializer(), serializedDefaultValue: undefined, deserializedDefaultValue: undefined }],
[Date, { serializer: new DateSerializer(), serializedDefaultValue: undefined, deserializedDefaultValue: undefined }],
[Float32Array, { serializer: new Float32ArraySerializer(), serializedDefaultValue: undefined, deserializedDefaultValue: undefined }],
[Float64Array, { serializer: new Float64ArraySerializer(), serializedDefaultValue: undefined, deserializedDefaultValue: undefined }],
[Int8Array, { serializer: new Int8ArraySerializer(), serializedDefaultValue: undefined, deserializedDefaultValue: undefined }],
[Int16Array, { serializer: new Int16ArraySerializer(), serializedDefaultValue: undefined, deserializedDefaultValue: undefined }],
[Int32Array, { serializer: new Int32ArraySerializer(), serializedDefaultValue: undefined, deserializedDefaultValue: undefined }],
[Map, { serializer: new MapSerializer(), serializedDefaultValue: undefined, deserializedDefaultValue: undefined }],
[Number, { serializer: new NumberSerializer(), serializedDefaultValue: 0, deserializedDefaultValue: 0 }],
[Set, { serializer: new SetSerializer(), serializedDefaultValue: undefined, deserializedDefaultValue: undefined }],
[String, { serializer: new StringSerializer(), serializedDefaultValue: undefined, deserializedDefaultValue: undefined }],
[Uint8Array, { serializer: new Uint8ArraySerializer(), serializedDefaultValue: undefined, deserializedDefaultValue: undefined }],
[Uint8ClampedArray, { serializer: new Uint8ClampedArraySerializer(), serializedDefaultValue: undefined, deserializedDefaultValue: undefined }],
[Uint16Array, { serializer: new Uint16ArraySerializer(), serializedDefaultValue: undefined, deserializedDefaultValue: undefined }],
[Uint32Array, { serializer: new Uint32ArraySerializer(), serializedDefaultValue: undefined, deserializedDefaultValue: undefined }],
[Unknown, { serializer: new UnknownSerializer(), serializedDefaultValue: undefined, deserializedDefaultValue: undefined }]
]);
TypeManager.staticTypeManager = new TypeManager();
TypeManager.typeScope = new TypeScope();
return TypeManager;
}());
export { TypeManager };
//# sourceMappingURL=type-manager.js.map