homebridge-config-ui-x
Version:
A web based management, configuration and control platform for Homebridge
822 lines • 60.3 kB
JavaScript
System.register("class-transformer/ClassTransformOptions", [], function (exports_1, context_1) {
var __moduleName = context_1 && context_1.id;
return {
setters: [],
execute: function () {
}
};
});
System.register("class-transformer/metadata/ExposeExcludeOptions", [], function (exports_2, context_2) {
var __moduleName = context_2 && context_2.id;
return {
setters: [],
execute: function () {
}
};
});
System.register("class-transformer/metadata/TypeMetadata", [], function (exports_3, context_3) {
var TypeMetadata;
var __moduleName = context_3 && context_3.id;
return {
setters: [],
execute: function () {
TypeMetadata = /** @class */ (function () {
function TypeMetadata(target, propertyName, reflectedType, typeFunction, options) {
this.target = target;
this.propertyName = propertyName;
this.reflectedType = reflectedType;
this.typeFunction = typeFunction;
this.options = options;
}
return TypeMetadata;
}());
exports_3("TypeMetadata", TypeMetadata);
}
};
});
System.register("class-transformer/metadata/ExposeMetadata", [], function (exports_4, context_4) {
var ExposeMetadata;
var __moduleName = context_4 && context_4.id;
return {
setters: [],
execute: function () {
ExposeMetadata = /** @class */ (function () {
function ExposeMetadata(target, propertyName, options) {
this.target = target;
this.propertyName = propertyName;
this.options = options;
}
return ExposeMetadata;
}());
exports_4("ExposeMetadata", ExposeMetadata);
}
};
});
System.register("class-transformer/metadata/ExcludeMetadata", [], function (exports_5, context_5) {
var ExcludeMetadata;
var __moduleName = context_5 && context_5.id;
return {
setters: [],
execute: function () {
ExcludeMetadata = /** @class */ (function () {
function ExcludeMetadata(target, propertyName, options) {
this.target = target;
this.propertyName = propertyName;
this.options = options;
}
return ExcludeMetadata;
}());
exports_5("ExcludeMetadata", ExcludeMetadata);
}
};
});
System.register("class-transformer/metadata/TransformMetadata", [], function (exports_6, context_6) {
var TransformMetadata;
var __moduleName = context_6 && context_6.id;
return {
setters: [],
execute: function () {
TransformMetadata = /** @class */ (function () {
function TransformMetadata(target, propertyName, transformFn, options) {
this.target = target;
this.propertyName = propertyName;
this.transformFn = transformFn;
this.options = options;
}
return TransformMetadata;
}());
exports_6("TransformMetadata", TransformMetadata);
}
};
});
System.register("class-transformer/metadata/MetadataStorage", ["class-transformer/TransformOperationExecutor"], function (exports_7, context_7) {
var TransformOperationExecutor_1, MetadataStorage;
var __moduleName = context_7 && context_7.id;
return {
setters: [
function (TransformOperationExecutor_1_1) {
TransformOperationExecutor_1 = TransformOperationExecutor_1_1;
}
],
execute: function () {
/**
* Storage all library metadata.
*/
MetadataStorage = /** @class */ (function () {
function MetadataStorage() {
// -------------------------------------------------------------------------
// Properties
// -------------------------------------------------------------------------
this._typeMetadatas = new Map();
this._transformMetadatas = new Map();
this._exposeMetadatas = new Map();
this._excludeMetadatas = new Map();
this._ancestorsMap = new Map();
}
// -------------------------------------------------------------------------
// Adder Methods
// -------------------------------------------------------------------------
MetadataStorage.prototype.addTypeMetadata = function (metadata) {
if (!this._typeMetadatas.has(metadata.target)) {
this._typeMetadatas.set(metadata.target, new Map());
}
this._typeMetadatas.get(metadata.target).set(metadata.propertyName, metadata);
};
MetadataStorage.prototype.addTransformMetadata = function (metadata) {
if (!this._transformMetadatas.has(metadata.target)) {
this._transformMetadatas.set(metadata.target, new Map());
}
if (!this._transformMetadatas.get(metadata.target).has(metadata.propertyName)) {
this._transformMetadatas.get(metadata.target).set(metadata.propertyName, []);
}
this._transformMetadatas.get(metadata.target).get(metadata.propertyName).push(metadata);
};
MetadataStorage.prototype.addExposeMetadata = function (metadata) {
if (!this._exposeMetadatas.has(metadata.target)) {
this._exposeMetadatas.set(metadata.target, new Map());
}
this._exposeMetadatas.get(metadata.target).set(metadata.propertyName, metadata);
};
MetadataStorage.prototype.addExcludeMetadata = function (metadata) {
if (!this._excludeMetadatas.has(metadata.target)) {
this._excludeMetadatas.set(metadata.target, new Map());
}
this._excludeMetadatas.get(metadata.target).set(metadata.propertyName, metadata);
};
// -------------------------------------------------------------------------
// Public Methods
// -------------------------------------------------------------------------
MetadataStorage.prototype.findTransformMetadatas = function (target, propertyName, transformationType) {
return this.findMetadatas(this._transformMetadatas, target, propertyName)
.filter(function (metadata) {
if (!metadata.options)
return true;
if (metadata.options.toClassOnly === true && metadata.options.toPlainOnly === true)
return true;
if (metadata.options.toClassOnly === true) {
return transformationType === TransformOperationExecutor_1.TransformationType.CLASS_TO_CLASS || transformationType === TransformOperationExecutor_1.TransformationType.PLAIN_TO_CLASS;
}
if (metadata.options.toPlainOnly === true) {
return transformationType === TransformOperationExecutor_1.TransformationType.CLASS_TO_PLAIN;
}
return true;
});
};
MetadataStorage.prototype.findExcludeMetadata = function (target, propertyName) {
return this.findMetadata(this._excludeMetadatas, target, propertyName);
};
MetadataStorage.prototype.findExposeMetadata = function (target, propertyName) {
return this.findMetadata(this._exposeMetadatas, target, propertyName);
};
MetadataStorage.prototype.findExposeMetadataByCustomName = function (target, name) {
return this.getExposedMetadatas(target).find(function (metadata) {
return metadata.options && metadata.options.name === name;
});
};
MetadataStorage.prototype.findTypeMetadata = function (target, propertyName) {
return this.findMetadata(this._typeMetadatas, target, propertyName);
};
MetadataStorage.prototype.getStrategy = function (target) {
var excludeMap = this._excludeMetadatas.get(target);
var exclude = excludeMap && excludeMap.get(undefined);
var exposeMap = this._exposeMetadatas.get(target);
var expose = exposeMap && exposeMap.get(undefined);
if ((exclude && expose) || (!exclude && !expose))
return "none";
return exclude ? "excludeAll" : "exposeAll";
};
MetadataStorage.prototype.getExposedMetadatas = function (target) {
return this.getMetadata(this._exposeMetadatas, target);
};
MetadataStorage.prototype.getExcludedMetadatas = function (target) {
return this.getMetadata(this._excludeMetadatas, target);
};
MetadataStorage.prototype.getExposedProperties = function (target, transformationType) {
return this.getExposedMetadatas(target)
.filter(function (metadata) {
if (!metadata.options)
return true;
if (metadata.options.toClassOnly === true && metadata.options.toPlainOnly === true)
return true;
if (metadata.options.toClassOnly === true) {
return transformationType === TransformOperationExecutor_1.TransformationType.CLASS_TO_CLASS || transformationType === TransformOperationExecutor_1.TransformationType.PLAIN_TO_CLASS;
}
if (metadata.options.toPlainOnly === true) {
return transformationType === TransformOperationExecutor_1.TransformationType.CLASS_TO_PLAIN;
}
return true;
})
.map(function (metadata) { return metadata.propertyName; });
};
MetadataStorage.prototype.getExcludedProperties = function (target, transformationType) {
return this.getExcludedMetadatas(target)
.filter(function (metadata) {
if (!metadata.options)
return true;
if (metadata.options.toClassOnly === true && metadata.options.toPlainOnly === true)
return true;
if (metadata.options.toClassOnly === true) {
return transformationType === TransformOperationExecutor_1.TransformationType.CLASS_TO_CLASS || transformationType === TransformOperationExecutor_1.TransformationType.PLAIN_TO_CLASS;
}
if (metadata.options.toPlainOnly === true) {
return transformationType === TransformOperationExecutor_1.TransformationType.CLASS_TO_PLAIN;
}
return true;
})
.map(function (metadata) { return metadata.propertyName; });
};
MetadataStorage.prototype.clear = function () {
this._typeMetadatas.clear();
this._exposeMetadatas.clear();
this._excludeMetadatas.clear();
this._ancestorsMap.clear();
};
// -------------------------------------------------------------------------
// Private Methods
// -------------------------------------------------------------------------
MetadataStorage.prototype.getMetadata = function (metadatas, target) {
var metadataFromTargetMap = metadatas.get(target);
var metadataFromTarget;
if (metadataFromTargetMap) {
metadataFromTarget = Array.from(metadataFromTargetMap.values()).filter(function (meta) { return meta.propertyName !== undefined; });
}
var metadataFromAncestors = [];
for (var _i = 0, _a = this.getAncestors(target); _i < _a.length; _i++) {
var ancestor = _a[_i];
var ancestorMetadataMap = metadatas.get(ancestor);
if (ancestorMetadataMap) {
var metadataFromAncestor = Array.from(ancestorMetadataMap.values()).filter(function (meta) { return meta.propertyName !== undefined; });
metadataFromAncestors.push.apply(metadataFromAncestors, metadataFromAncestor);
}
}
return metadataFromAncestors.concat(metadataFromTarget || []);
};
MetadataStorage.prototype.findMetadata = function (metadatas, target, propertyName) {
var metadataFromTargetMap = metadatas.get(target);
if (metadataFromTargetMap) {
var metadataFromTarget = metadataFromTargetMap.get(propertyName);
if (metadataFromTarget) {
return metadataFromTarget;
}
}
for (var _i = 0, _a = this.getAncestors(target); _i < _a.length; _i++) {
var ancestor = _a[_i];
var ancestorMetadataMap = metadatas.get(ancestor);
if (ancestorMetadataMap) {
var ancestorResult = ancestorMetadataMap.get(propertyName);
if (ancestorResult) {
return ancestorResult;
}
}
}
return undefined;
};
MetadataStorage.prototype.findMetadatas = function (metadatas, target, propertyName) {
var metadataFromTargetMap = metadatas.get(target);
var metadataFromTarget;
if (metadataFromTargetMap) {
metadataFromTarget = metadataFromTargetMap.get(propertyName);
}
var metadataFromAncestorsTarget = [];
for (var _i = 0, _a = this.getAncestors(target); _i < _a.length; _i++) {
var ancestor = _a[_i];
var ancestorMetadataMap = metadatas.get(ancestor);
if (ancestorMetadataMap) {
if (ancestorMetadataMap.has(propertyName)) {
metadataFromAncestorsTarget.push.apply(metadataFromAncestorsTarget, ancestorMetadataMap.get(propertyName));
}
}
}
return (metadataFromAncestorsTarget).reverse().concat((metadataFromTarget || []).reverse());
};
MetadataStorage.prototype.getAncestors = function (target) {
if (!target)
return [];
if (!this._ancestorsMap.has(target)) {
var ancestors = [];
for (var baseClass = Object.getPrototypeOf(target.prototype.constructor); typeof baseClass.prototype !== "undefined"; baseClass = Object.getPrototypeOf(baseClass.prototype.constructor)) {
ancestors.push(baseClass);
}
this._ancestorsMap.set(target, ancestors);
}
return this._ancestorsMap.get(target);
};
return MetadataStorage;
}());
exports_7("MetadataStorage", MetadataStorage);
}
};
});
System.register("class-transformer/storage", ["class-transformer/metadata/MetadataStorage"], function (exports_8, context_8) {
var MetadataStorage_1, defaultMetadataStorage;
var __moduleName = context_8 && context_8.id;
return {
setters: [
function (MetadataStorage_1_1) {
MetadataStorage_1 = MetadataStorage_1_1;
}
],
execute: function () {
/**
* Default metadata storage is used as singleton and can be used to storage all metadatas.
*/
exports_8("defaultMetadataStorage", defaultMetadataStorage = new MetadataStorage_1.MetadataStorage());
}
};
});
System.register("class-transformer/TransformOperationExecutor", ["class-transformer/storage"], function (exports_9, context_9) {
var storage_1, TransformationType, TransformOperationExecutor;
var __moduleName = context_9 && context_9.id;
function instantiateArrayType(arrayType) {
var array = new arrayType();
if (!(array instanceof Set) && !("push" in array)) {
return [];
}
return array;
}
function testForBuffer() {
try {
Buffer;
return true;
}
catch (_a) { }
return false;
}
exports_9("testForBuffer", testForBuffer);
return {
setters: [
function (storage_1_1) {
storage_1 = storage_1_1;
}
],
execute: function () {
(function (TransformationType) {
TransformationType[TransformationType["PLAIN_TO_CLASS"] = 0] = "PLAIN_TO_CLASS";
TransformationType[TransformationType["CLASS_TO_PLAIN"] = 1] = "CLASS_TO_PLAIN";
TransformationType[TransformationType["CLASS_TO_CLASS"] = 2] = "CLASS_TO_CLASS";
})(TransformationType || (TransformationType = {}));
exports_9("TransformationType", TransformationType);
TransformOperationExecutor = /** @class */ (function () {
// -------------------------------------------------------------------------
// Constructor
// -------------------------------------------------------------------------
function TransformOperationExecutor(transformationType, options) {
this.transformationType = transformationType;
this.options = options;
// -------------------------------------------------------------------------
// Private Properties
// -------------------------------------------------------------------------
this.recursionStack = new Set();
}
// -------------------------------------------------------------------------
// Public Methods
// -------------------------------------------------------------------------
TransformOperationExecutor.prototype.transform = function (source, value, targetType, arrayType, isMap, level) {
var _this = this;
if (level === void 0) { level = 0; }
if (Array.isArray(value) || value instanceof Set) {
var newValue_1 = arrayType && this.transformationType === TransformationType.PLAIN_TO_CLASS ? instantiateArrayType(arrayType) : [];
value.forEach(function (subValue, index) {
var subSource = source ? source[index] : undefined;
if (!_this.options.enableCircularCheck || !_this.isCircular(subValue)) {
var realTargetType = void 0;
if (typeof targetType !== "function" && targetType && targetType.options && targetType.options.discriminator && targetType.options.discriminator.property && targetType.options.discriminator.subTypes) {
if (_this.transformationType === TransformationType.PLAIN_TO_CLASS) {
realTargetType = targetType.options.discriminator.subTypes.find(function (subType) { return subType.name === subValue[targetType.options.discriminator.property]; });
var options = { newObject: newValue_1, object: subValue, property: undefined };
var newType = targetType.typeFunction(options);
realTargetType === undefined ? realTargetType = newType : realTargetType = realTargetType.value;
if (!targetType.options.keepDiscriminatorProperty)
delete subValue[targetType.options.discriminator.property];
}
if (_this.transformationType === TransformationType.CLASS_TO_CLASS) {
realTargetType = subValue.constructor;
}
if (_this.transformationType === TransformationType.CLASS_TO_PLAIN) {
subValue[targetType.options.discriminator.property] = targetType.options.discriminator.subTypes.find(function (subType) { return subType.value === subValue.constructor; }).name;
}
}
else {
realTargetType = targetType;
}
var value_1 = _this.transform(subSource, subValue, realTargetType, undefined, subValue instanceof Map, level + 1);
if (newValue_1 instanceof Set) {
newValue_1.add(value_1);
}
else {
newValue_1.push(value_1);
}
}
else if (_this.transformationType === TransformationType.CLASS_TO_CLASS) {
if (newValue_1 instanceof Set) {
newValue_1.add(subValue);
}
else {
newValue_1.push(subValue);
}
}
});
return newValue_1;
}
else if (targetType === String && !isMap) {
if (value === null || value === undefined)
return value;
return String(value);
}
else if (targetType === Number && !isMap) {
if (value === null || value === undefined)
return value;
return Number(value);
}
else if (targetType === Boolean && !isMap) {
if (value === null || value === undefined)
return value;
return Boolean(value);
}
else if ((targetType === Date || value instanceof Date) && !isMap) {
if (value instanceof Date) {
return new Date(value.valueOf());
}
if (value === null || value === undefined)
return value;
return new Date(value);
}
else if (testForBuffer() && (targetType === Buffer || value instanceof Buffer) && !isMap) {
if (value === null || value === undefined)
return value;
return Buffer.from(value);
}
else if (typeof value === "object" && value !== null) {
// try to guess the type
if (!targetType && value.constructor !== Object /* && TransformationType === TransformationType.CLASS_TO_PLAIN*/)
targetType = value.constructor;
if (!targetType && source)
targetType = source.constructor;
if (this.options.enableCircularCheck) {
// add transformed type to prevent circular references
this.recursionStack.add(value);
}
var keys = this.getKeys(targetType, value);
var newValue = source ? source : {};
if (!source && (this.transformationType === TransformationType.PLAIN_TO_CLASS || this.transformationType === TransformationType.CLASS_TO_CLASS)) {
if (isMap) {
newValue = new Map();
}
else if (targetType) {
newValue = new targetType();
}
else {
newValue = {};
}
}
var _loop_1 = function (key) {
var valueKey = key, newValueKey = key, propertyName = key;
if (!this_1.options.ignoreDecorators && targetType) {
if (this_1.transformationType === TransformationType.PLAIN_TO_CLASS) {
var exposeMetadata = storage_1.defaultMetadataStorage.findExposeMetadataByCustomName(targetType, key);
if (exposeMetadata) {
propertyName = exposeMetadata.propertyName;
newValueKey = exposeMetadata.propertyName;
}
}
else if (this_1.transformationType === TransformationType.CLASS_TO_PLAIN || this_1.transformationType === TransformationType.CLASS_TO_CLASS) {
var exposeMetadata = storage_1.defaultMetadataStorage.findExposeMetadata(targetType, key);
if (exposeMetadata && exposeMetadata.options && exposeMetadata.options.name) {
newValueKey = exposeMetadata.options.name;
}
}
}
// get a subvalue
var subValue = undefined;
if (value instanceof Map) {
subValue = value.get(valueKey);
}
else if (value[valueKey] instanceof Function) {
subValue = value[valueKey]();
}
else {
subValue = value[valueKey];
}
// determine a type
var type = undefined, isSubValueMap = subValue instanceof Map;
if (targetType && isMap) {
type = targetType;
}
else if (targetType) {
var metadata_1 = storage_1.defaultMetadataStorage.findTypeMetadata(targetType, propertyName);
if (metadata_1) {
var options = { newObject: newValue, object: value, property: propertyName };
var newType = metadata_1.typeFunction ? metadata_1.typeFunction(options) : metadata_1.reflectedType;
if (metadata_1.options && metadata_1.options.discriminator && metadata_1.options.discriminator.property && metadata_1.options.discriminator.subTypes) {
if (!(value[valueKey] instanceof Array)) {
if (this_1.transformationType === TransformationType.PLAIN_TO_CLASS) {
type = metadata_1.options.discriminator.subTypes.find(function (subType) {
if (subValue && metadata_1.options.discriminator.property in subValue) {
return subType.name === subValue[metadata_1.options.discriminator.property];
}
});
type === undefined ? type = newType : type = type.value;
if (!metadata_1.options.keepDiscriminatorProperty) {
if (subValue && metadata_1.options.discriminator.property in subValue) {
delete subValue[metadata_1.options.discriminator.property];
}
}
}
if (this_1.transformationType === TransformationType.CLASS_TO_CLASS) {
type = subValue.constructor;
}
if (this_1.transformationType === TransformationType.CLASS_TO_PLAIN) {
subValue[metadata_1.options.discriminator.property] = metadata_1.options.discriminator.subTypes.find(function (subType) { return subType.value === subValue.constructor; }).name;
}
}
else {
type = metadata_1;
}
}
else {
type = newType;
}
isSubValueMap = isSubValueMap || metadata_1.reflectedType === Map;
}
else if (this_1.options.targetMaps) { // try to find a type in target maps
this_1.options.targetMaps
.filter(function (map) { return map.target === targetType && !!map.properties[propertyName]; })
.forEach(function (map) { return type = map.properties[propertyName]; });
}
else if (this_1.options.enableImplicitConversion && this_1.transformationType === TransformationType.PLAIN_TO_CLASS) {
// if we have no registererd type via the @Type() decorator then we check if we have any
// type declarations in reflect-metadata (type declaration is emited only if some decorator is added to the property.)
var reflectedType = Reflect.getMetadata("design:type", targetType.prototype, propertyName);
if (reflectedType) {
type = reflectedType;
}
}
}
// if value is an array try to get its custom array type
var arrayType_1 = Array.isArray(value[valueKey]) ? this_1.getReflectedType(targetType, propertyName) : undefined;
// const subValueKey = TransformationType === TransformationType.PLAIN_TO_CLASS && newKeyName ? newKeyName : key;
var subSource = source ? source[valueKey] : undefined;
// if its deserialization then type if required
// if we uncomment this types like string[] will not work
// if (this.transformationType === TransformationType.PLAIN_TO_CLASS && !type && subValue instanceof Object && !(subValue instanceof Date))
// throw new Error(`Cannot determine type for ${(targetType as any).name }.${propertyName}, did you forget to specify a @Type?`);
// if newValue is a source object that has method that match newKeyName then skip it
if (newValue.constructor.prototype) {
var descriptor = Object.getOwnPropertyDescriptor(newValue.constructor.prototype, newValueKey);
if ((this_1.transformationType === TransformationType.PLAIN_TO_CLASS || this_1.transformationType === TransformationType.CLASS_TO_CLASS)
&& ((descriptor && !descriptor.set) || newValue[newValueKey] instanceof Function)) // || TransformationType === TransformationType.CLASS_TO_CLASS
return "continue";
}
if (!this_1.options.enableCircularCheck || !this_1.isCircular(subValue)) {
var transformKey = this_1.transformationType === TransformationType.PLAIN_TO_CLASS ? newValueKey : key;
var finalValue = void 0;
if (this_1.transformationType === TransformationType.CLASS_TO_PLAIN) {
// Get original value
finalValue = value[transformKey];
// Apply custom transformation
finalValue = this_1.applyCustomTransformations(finalValue, targetType, transformKey, value, this_1.transformationType);
// If nothing change, it means no custom transformation was applied, so use the subValue.
finalValue = (value[transformKey] === finalValue) ? subValue : finalValue;
// Apply the default transformation
finalValue = this_1.transform(subSource, finalValue, type, arrayType_1, isSubValueMap, level + 1);
}
else {
finalValue = this_1.transform(subSource, subValue, type, arrayType_1, isSubValueMap, level + 1);
finalValue = this_1.applyCustomTransformations(finalValue, targetType, transformKey, value, this_1.transformationType);
}
if (newValue instanceof Map) {
newValue.set(newValueKey, finalValue);
}
else {
newValue[newValueKey] = finalValue;
}
}
else if (this_1.transformationType === TransformationType.CLASS_TO_CLASS) {
var finalValue = subValue;
finalValue = this_1.applyCustomTransformations(finalValue, targetType, key, value, this_1.transformationType);
if (newValue instanceof Map) {
newValue.set(newValueKey, finalValue);
}
else {
newValue[newValueKey] = finalValue;
}
}
};
var this_1 = this;
// traverse over keys
for (var _i = 0, keys_1 = keys; _i < keys_1.length; _i++) {
var key = keys_1[_i];
_loop_1(key);
}
if (this.options.enableCircularCheck) {
this.recursionStack.delete(value);
}
return newValue;
}
else {
return value;
}
};
TransformOperationExecutor.prototype.applyCustomTransformations = function (value, target, key, obj, transformationType) {
var _this = this;
var metadatas = storage_1.defaultMetadataStorage.findTransformMetadatas(target, key, this.transformationType);
// apply versioning options
if (this.options.version !== undefined) {
metadatas = metadatas.filter(function (metadata) {
if (!metadata.options)
return true;
return _this.checkVersion(metadata.options.since, metadata.options.until);
});
}
// apply grouping options
if (this.options.groups && this.options.groups.length) {
metadatas = metadatas.filter(function (metadata) {
if (!metadata.options)
return true;
return _this.checkGroups(metadata.options.groups);
});
}
else {
metadatas = metadatas.filter(function (metadata) {
return !metadata.options || !metadata.options.groups || !metadata.options.groups.length;
});
}
metadatas.forEach(function (metadata) {
value = metadata.transformFn(value, obj, transformationType);
});
return value;
};
// preventing circular references
TransformOperationExecutor.prototype.isCircular = function (object) {
return this.recursionStack.has(object);
};
TransformOperationExecutor.prototype.getReflectedType = function (target, propertyName) {
if (!target)
return undefined;
var meta = storage_1.defaultMetadataStorage.findTypeMetadata(target, propertyName);
return meta ? meta.reflectedType : undefined;
};
TransformOperationExecutor.prototype.getKeys = function (target, object) {
var _this = this;
// determine exclusion strategy
var strategy = storage_1.defaultMetadataStorage.getStrategy(target);
if (strategy === "none")
strategy = this.options.strategy || "exposeAll"; // exposeAll is default strategy
// get all keys that need to expose
var keys = [];
if (strategy === "exposeAll") {
if (object instanceof Map) {
keys = Array.from(object.keys());
}
else {
keys = Object.keys(object);
}
}
if (!this.options.ignoreDecorators && target) {
// add all exposed to list of keys
var exposedProperties = storage_1.defaultMetadataStorage.getExposedProperties(target, this.transformationType);
if (this.transformationType === TransformationType.PLAIN_TO_CLASS) {
exposedProperties = exposedProperties.map(function (key) {
var exposeMetadata = storage_1.defaultMetadataStorage.findExposeMetadata(target, key);
if (exposeMetadata && exposeMetadata.options && exposeMetadata.options.name) {
return exposeMetadata.options.name;
}
return key;
});
}
if (this.options.excludeExtraneousValues) {
keys = exposedProperties;
}
else {
keys = keys.concat(exposedProperties);
}
// exclude excluded properties
var excludedProperties_1 = storage_1.defaultMetadataStorage.getExcludedProperties(target, this.transformationType);
if (excludedProperties_1.length > 0) {
keys = keys.filter(function (key) {
return excludedProperties_1.indexOf(key) === -1;
});
}
// apply versioning options
if (this.options.version !== undefined) {
keys = keys.filter(function (key) {
var exposeMetadata = storage_1.defaultMetadataStorage.findExposeMetadata(target, key);
if (!exposeMetadata || !exposeMetadata.options)
return true;
return _this.checkVersion(exposeMetadata.options.since, exposeMetadata.options.until);
});
}
// apply grouping options
if (this.options.groups && this.options.groups.length) {
keys = keys.filter(function (key) {
var exposeMetadata = storage_1.defaultMetadataStorage.findExposeMetadata(target, key);
if (!exposeMetadata || !exposeMetadata.options)
return true;
return _this.checkGroups(exposeMetadata.options.groups);
});
}
else {
keys = keys.filter(function (key) {
var exposeMetadata = storage_1.defaultMetadataStorage.findExposeMetadata(target, key);
return !exposeMetadata || !exposeMetadata.options || !exposeMetadata.options.groups || !exposeMetadata.options.groups.length;
});
}
}
// exclude prefixed properties
if (this.options.excludePrefixes && this.options.excludePrefixes.length) {
keys = keys.filter(function (key) { return _this.options.excludePrefixes.every(function (prefix) {
return key.substr(0, prefix.length) !== prefix;
}); });
}
// make sure we have unique keys
keys = keys.filter(function (key, index, self) {
return self.indexOf(key) === index;
});
return keys;
};
TransformOperationExecutor.prototype.checkVersion = function (since, until) {
var decision = true;
if (decision && since)
decision = this.options.version >= since;
if (decision && until)
decision = this.options.version < until;
return decision;
};
TransformOperationExecutor.prototype.checkGroups = function (groups) {
if (!groups)
return true;
return this.options.groups.some(function (optionGroup) { return groups.indexOf(optionGroup) !== -1; });
};
return TransformOperationExecutor;
}());
exports_9("TransformOperationExecutor", TransformOperationExecutor);
}
};
});
System.register("class-transformer/ClassTransformer", ["class-transformer/TransformOperationExecutor"], function (exports_10, context_10) {
var TransformOperationExecutor_2, ClassTransformer;
var __moduleName = context_10 && context_10.id;
return {
setters: [
function (TransformOperationExecutor_2_1) {
TransformOperationExecutor_2 = TransformOperationExecutor_2_1;
}
],
execute: function () {
ClassTransformer = /** @class */ (function () {
function ClassTransformer() {
}
ClassTransformer.prototype.classToPlain = function (object, options) {
var executor = new TransformOperationExecutor_2.TransformOperationExecutor(TransformOperationExecutor_2.TransformationType.CLASS_TO_PLAIN, options || {});
return executor.transform(undefined, object, undefined, undefined, undefined, undefined);
};
ClassTransformer.prototype.classToPlainFromExist = function (object, plainObject, options) {
var executor = new TransformOperationExecutor_2.TransformOperationExecutor(TransformOperationExecutor_2.TransformationType.CLASS_TO_PLAIN, options || {});
return executor.transform(plainObject, object, undefined, undefined, undefined, undefined);
};
ClassTransformer.prototype.plainToClass = function (cls, plain, options) {
var executor = new TransformOperationExecutor_2.TransformOperationExecutor(TransformOperationExecutor_2.TransformationType.PLAIN_TO_CLASS, options || {});
return executor.transform(undefined, plain, cls, undefined, undefined, undefined);
};
ClassTransformer.prototype.plainToClassFromExist = function (clsObject, plain, options) {
var executor = new TransformOperationExecutor_2.TransformOperationExecutor(TransformOperationExecutor_2.TransformationType.PLAIN_TO_CLASS, options || {});
return executor.transform(clsObject, plain, undefined, undefined, undefined, undefined);
};
ClassTransformer.prototype.classToClass = function (object, options) {
var executor = new TransformOperationExecutor_2.TransformOperationExecutor(TransformOperationExecutor_2.TransformationType.CLASS_TO_CLASS, options || {});
return executor.transform(undefined, object, undefined, undefined, undefined, undefined);
};
ClassTransformer.prototype.classToClassFromExist = function (object, fromObject, options) {
var executor = new TransformOperationExecutor_2.TransformOperationExecutor(TransformOperationExecutor_2.TransformationType.CLASS_TO_CLASS, options || {});
return executor.transform(fromObject, object, undefined, undefined, undefined, undefined);
};
ClassTransformer.prototype.serialize = function (object, options) {
return JSON.stringify(this.classToPlain(object, options));
};
/**
* Deserializes given JSON string to a object of the given class.
*/
ClassTransformer.prototype.deserialize = function (cls, json, options) {
var jsonObject = JSON.parse(json);
return this.plainToClass(cls, jsonObject, options);
};
/**
* Deserializes given JSON string to an array of objects of the given class.
*/
ClassTransformer.prototype.deserializeArray = function (cls, json, options) {
var jsonObject = JSON.parse(json);
return this.plainToClass(cls, jsonObject, options);
};
return ClassTransformer;
}());
exports_10("ClassTransformer", ClassTransformer);
}
};
});
System.register("class-transformer/decorators", ["class-transformer/ClassTransformer", "class-transformer/storage", "class-transformer/metadata/TypeMetadata", "class-transformer/metadata/ExposeMetadata", "class-transformer/metadata/ExcludeMetadata", "class-transformer/metadata/TransformMetadata"], function (exports_11, context_11) {
var ClassTransformer_1, storage_2, TypeMetadata_1, ExposeMetadata_1, ExcludeMetadata_1, TransformMetadata_1;
var __moduleName = context_11 && context_11.id;
/**
* Defines a custom logic for value transformation.
*/
function Tra