@dipscope/type-manager 7.0.0-beta.0 → 7.0.1

package/dist/es5/serializers/type-serializer.js

@@ -1,154 +1,154 @@
-import { __values } from "tslib";
-import { isNil, isNull, isObject, isUndefined } from 'lodash';
-import { TypeContext } from '../type-context';
-import { TypeContextEntry } from '../type-context-entry';
-var TypeSerializer = (function () {
-    function TypeSerializer() {
-    }
-    TypeSerializer.prototype.serialize = function (x, serializerContext) {
-        if (isUndefined(x)) {
-            return serializerContext.serializedDefaultValue;
-        }
-        if (isNull(x)) {
-            return serializerContext.serializedNullValue;
-        }
-        if (isObject(x)) {
-            return serializerContext.defineReference(x, function () {
-                var e_1, _a;
-                var type = x;
-                var typeSerializerContext = serializerContext.polymorphic
-                    ? serializerContext.definePolymorphicSerializerContext(x.constructor)
-                    : serializerContext;
-                var propertySerializerContext = typeSerializerContext.defineChildSerializerContext({
-                    jsonPathKey: typeSerializerContext.jsonPathKey
-                });
-                var typeMetadata = typeSerializerContext.typeMetadata;
-                var object = {};
-                var _loop_1 = function (propertyMetadata) {
-                    if (propertyMetadata.serializationConfigured && !propertyMetadata.serializable) {
-                        return "continue";
-                    }
-                    var serializedPropertyName = propertyMetadata.serializedPropertyName;
-                    var deserializedPropertyName = propertyMetadata.deserializedPropertyName;
-                    var propertyValue = type[deserializedPropertyName];
-                    propertySerializerContext.hasJsonPathKey(serializedPropertyName);
-                    propertySerializerContext.hasPropertyMetadata(propertyMetadata);
-                    propertySerializerContext.hasTypeMetadata(propertyMetadata.typeMetadata);
-                    propertySerializerContext.hasGenericStructures(propertyMetadata.genericStructures);
-                    propertySerializerContext.hasGenericMetadataResolvers(propertyMetadata.genericMetadataResolvers);
-                    propertySerializerContext.hasReferenceValueSetter(function (v) {
-                        var declaringObject = propertySerializerContext.referenceMap.get(type);
-                        if (!isNil(declaringObject)) {
-                            declaringObject[serializedPropertyName] = v;
-                        }
-                    });
-                    var value = propertySerializerContext.serialize(propertyValue);
-                    object[serializedPropertyName] = value;
-                };
-                try {
-                    for (var _b = __values(typeMetadata.sortedPropertyMetadatas), _c = _b.next(); !_c.done; _c = _b.next()) {
-                        var propertyMetadata = _c.value;
-                        _loop_1(propertyMetadata);
-                    }
-                }
-                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; }
-                }
-                if (typeSerializerContext.preserveDiscriminator) {
-                    object[typeSerializerContext.discriminator] = typeSerializerContext.discriminant;
-                }
-                else if (object.hasOwnProperty(typeSerializerContext.discriminator)) {
-                    delete object[typeSerializerContext.discriminator];
-                }
-                return object;
-            });
-        }
-        if (serializerContext.log.errorEnabled) {
-            serializerContext.log.error("".concat(serializerContext.jsonPath, ": cannot serialize value as type."), x);
-        }
-        return undefined;
-    };
-    TypeSerializer.prototype.deserialize = function (x, serializerContext) {
-        if (isUndefined(x)) {
-            return serializerContext.deserializedDefaultValue;
-        }
-        if (isNull(x)) {
-            return serializerContext.deserializedNullValue;
-        }
-        if (isObject(x)) {
-            return serializerContext.restoreReference(x, function () {
-                var e_2, _a;
-                var object = x;
-                var typeSerializerContext = serializerContext.polymorphic
-                    ? serializerContext.definePolymorphicSerializerContext(x)
-                    : serializerContext;
-                var propertySerializerContext = typeSerializerContext.defineChildSerializerContext({
-                    jsonPathKey: typeSerializerContext.jsonPath
-                });
-                var typeMetadata = typeSerializerContext.typeMetadata;
-                var typeContext = new TypeContext(typeMetadata);
-                var _loop_2 = function (propertyMetadata) {
-                    if (propertyMetadata.serializationConfigured && !propertyMetadata.deserializable) {
-                        return "continue";
-                    }
-                    var serializedPropertyName = propertyMetadata.serializedPropertyName;
-                    var deserializedPropertyName = propertyMetadata.deserializedPropertyName;
-                    var propertyValue = object[serializedPropertyName];
-                    propertySerializerContext.hasJsonPathKey(deserializedPropertyName);
-                    propertySerializerContext.hasPropertyMetadata(propertyMetadata);
-                    propertySerializerContext.hasTypeMetadata(propertyMetadata.typeMetadata);
-                    propertySerializerContext.hasGenericStructures(propertyMetadata.genericStructures);
-                    propertySerializerContext.hasGenericMetadataResolvers(propertyMetadata.genericMetadataResolvers);
-                    propertySerializerContext.hasReferenceValueSetter(function (v) {
-                        var declaringType = propertySerializerContext.referenceMap.get(object);
-                        if (!isNil(declaringType)) {
-                            declaringType[deserializedPropertyName] = v;
-                        }
-                    });
-                    var value = propertySerializerContext.deserialize(propertyValue);
-                    typeContext.set(deserializedPropertyName, new TypeContextEntry(deserializedPropertyName, value, propertyMetadata));
-                    typeContext.set(serializedPropertyName, new TypeContextEntry(serializedPropertyName, value, propertyMetadata));
-                };
-                try {
-                    for (var _b = __values(typeMetadata.sortedPropertyMetadatas), _c = _b.next(); !_c.done; _c = _b.next()) {
-                        var propertyMetadata = _c.value;
-                        _loop_2(propertyMetadata);
-                    }
-                }
-                catch (e_2_1) { e_2 = { error: e_2_1 }; }
-                finally {
-                    try {
-                        if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
-                    }
-                    finally { if (e_2) throw e_2.error; }
-                }
-                for (var propertyName in object) {
-                    if (object.hasOwnProperty(propertyName)) {
-                        typeContext.set(propertyName, new TypeContextEntry(propertyName, object[propertyName]));
-                    }
-                }
-                var factory = typeSerializerContext.factory;
-                var injector = typeSerializerContext.injector;
-                var type = factory.build(typeContext, injector);
-                if (typeSerializerContext.preserveDiscriminator) {
-                    type[typeSerializerContext.discriminator] = typeSerializerContext.discriminant;
-                }
-                else if (type.hasOwnProperty(typeSerializerContext.discriminator)) {
-                    delete type[typeSerializerContext.discriminator];
-                }
-                return type;
-            });
-        }
-        if (serializerContext.log.errorEnabled) {
-            serializerContext.log.error("".concat(serializerContext.jsonPath, ": cannot deserialize value as type."), x);
-        }
-        return undefined;
-    };
-    return TypeSerializer;
-}());
-export { TypeSerializer };
+import { __values } from "tslib";
+import { isNil, isNull, isObject, isUndefined } from 'lodash';
+import { TypeContext } from '../type-context';
+import { TypeContextEntry } from '../type-context-entry';
+var TypeSerializer = (function () {
+    function TypeSerializer() {
+    }
+    TypeSerializer.prototype.serialize = function (x, serializerContext) {
+        if (isUndefined(x)) {
+            return serializerContext.serializedDefaultValue;
+        }
+        if (isNull(x)) {
+            return serializerContext.serializedNullValue;
+        }
+        if (isObject(x)) {
+            return serializerContext.defineReference(x, function () {
+                var e_1, _a;
+                var type = x;
+                var typeSerializerContext = serializerContext.polymorphic
+                    ? serializerContext.definePolymorphicSerializerContext(x.constructor)
+                    : serializerContext;
+                var propertySerializerContext = typeSerializerContext.defineChildSerializerContext({
+                    jsonPathKey: typeSerializerContext.jsonPathKey
+                });
+                var typeMetadata = typeSerializerContext.typeMetadata;
+                var object = {};
+                var _loop_1 = function (propertyMetadata) {
+                    if (propertyMetadata.serializationConfigured && !propertyMetadata.serializable) {
+                        return "continue";
+                    }
+                    var serializedPropertyName = propertyMetadata.serializedPropertyName;
+                    var deserializedPropertyName = propertyMetadata.deserializedPropertyName;
+                    var propertyValue = type[deserializedPropertyName];
+                    propertySerializerContext.hasJsonPathKey(serializedPropertyName);
+                    propertySerializerContext.hasPropertyMetadata(propertyMetadata);
+                    propertySerializerContext.hasTypeMetadata(propertyMetadata.typeMetadata);
+                    propertySerializerContext.hasGenericStructures(propertyMetadata.genericStructures);
+                    propertySerializerContext.hasGenericMetadataResolvers(propertyMetadata.genericMetadataResolvers);
+                    propertySerializerContext.hasReferenceValueSetter(function (v) {
+                        var declaringObject = propertySerializerContext.referenceMap.get(type);
+                        if (!isNil(declaringObject)) {
+                            declaringObject[serializedPropertyName] = v;
+                        }
+                    });
+                    var value = propertySerializerContext.serialize(propertyValue);
+                    object[serializedPropertyName] = value;
+                };
+                try {
+                    for (var _b = __values(typeMetadata.sortedPropertyMetadatas), _c = _b.next(); !_c.done; _c = _b.next()) {
+                        var propertyMetadata = _c.value;
+                        _loop_1(propertyMetadata);
+                    }
+                }
+                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; }
+                }
+                if (typeSerializerContext.preserveDiscriminator) {
+                    object[typeSerializerContext.discriminator] = typeSerializerContext.discriminant;
+                }
+                else if (object.hasOwnProperty(typeSerializerContext.discriminator)) {
+                    delete object[typeSerializerContext.discriminator];
+                }
+                return object;
+            });
+        }
+        if (serializerContext.log.errorEnabled) {
+            serializerContext.log.error("".concat(serializerContext.jsonPath, ": cannot serialize value as type."), x);
+        }
+        return undefined;
+    };
+    TypeSerializer.prototype.deserialize = function (x, serializerContext) {
+        if (isUndefined(x)) {
+            return serializerContext.deserializedDefaultValue;
+        }
+        if (isNull(x)) {
+            return serializerContext.deserializedNullValue;
+        }
+        if (isObject(x)) {
+            return serializerContext.restoreReference(x, function () {
+                var e_2, _a;
+                var object = x;
+                var typeSerializerContext = serializerContext.polymorphic
+                    ? serializerContext.definePolymorphicSerializerContext(x)
+                    : serializerContext;
+                var propertySerializerContext = typeSerializerContext.defineChildSerializerContext({
+                    jsonPathKey: typeSerializerContext.jsonPath
+                });
+                var typeMetadata = typeSerializerContext.typeMetadata;
+                var typeContext = new TypeContext(typeMetadata);
+                var _loop_2 = function (propertyMetadata) {
+                    if (propertyMetadata.serializationConfigured && !propertyMetadata.deserializable) {
+                        return "continue";
+                    }
+                    var serializedPropertyName = propertyMetadata.serializedPropertyName;
+                    var deserializedPropertyName = propertyMetadata.deserializedPropertyName;
+                    var propertyValue = object[serializedPropertyName];
+                    propertySerializerContext.hasJsonPathKey(deserializedPropertyName);
+                    propertySerializerContext.hasPropertyMetadata(propertyMetadata);
+                    propertySerializerContext.hasTypeMetadata(propertyMetadata.typeMetadata);
+                    propertySerializerContext.hasGenericStructures(propertyMetadata.genericStructures);
+                    propertySerializerContext.hasGenericMetadataResolvers(propertyMetadata.genericMetadataResolvers);
+                    propertySerializerContext.hasReferenceValueSetter(function (v) {
+                        var declaringType = propertySerializerContext.referenceMap.get(object);
+                        if (!isNil(declaringType)) {
+                            declaringType[deserializedPropertyName] = v;
+                        }
+                    });
+                    var value = propertySerializerContext.deserialize(propertyValue);
+                    typeContext.set(deserializedPropertyName, new TypeContextEntry(deserializedPropertyName, value, propertyMetadata));
+                    typeContext.set(serializedPropertyName, new TypeContextEntry(serializedPropertyName, value, propertyMetadata));
+                };
+                try {
+                    for (var _b = __values(typeMetadata.sortedPropertyMetadatas), _c = _b.next(); !_c.done; _c = _b.next()) {
+                        var propertyMetadata = _c.value;
+                        _loop_2(propertyMetadata);
+                    }
+                }
+                catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                finally {
+                    try {
+                        if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                    }
+                    finally { if (e_2) throw e_2.error; }
+                }
+                for (var propertyName in object) {
+                    if (object.hasOwnProperty(propertyName)) {
+                        typeContext.set(propertyName, new TypeContextEntry(propertyName, object[propertyName]));
+                    }
+                }
+                var factory = typeSerializerContext.factory;
+                var injector = typeSerializerContext.injector;
+                var type = factory.build(typeContext, injector);
+                if (typeSerializerContext.preserveDiscriminator) {
+                    type[typeSerializerContext.discriminator] = typeSerializerContext.discriminant;
+                }
+                else if (type.hasOwnProperty(typeSerializerContext.discriminator)) {
+                    delete type[typeSerializerContext.discriminator];
+                }
+                return type;
+            });
+        }
+        if (serializerContext.log.errorEnabled) {
+            serializerContext.log.error("".concat(serializerContext.jsonPath, ": cannot deserialize value as type."), x);
+        }
+        return undefined;
+    };
+    return TypeSerializer;
+}());
+export { TypeSerializer };
 //# sourceMappingURL=type-serializer.js.map

package/dist/es5/serializers/uint-16-array-serializer.js

@@ -1,39 +1,39 @@
-import { isArray, isNull, isUndefined } from 'lodash';
-import { isUint16Array } from '../functions/is-uint-16-array';
-var Uint16ArraySerializer = (function () {
-    function Uint16ArraySerializer() {
-    }
-    Uint16ArraySerializer.prototype.serialize = function (x, serializerContext) {
-        if (isUndefined(x)) {
-            return serializerContext.serializedDefaultValue;
-        }
-        if (isNull(x)) {
-            return serializerContext.serializedNullValue;
-        }
-        if (isUint16Array(x)) {
-            return Array.from(x);
-        }
-        if (serializerContext.log.errorEnabled) {
-            serializerContext.log.error("".concat(serializerContext.jsonPath, ": cannot serialize value as uint 16 array."), x);
-        }
-        return undefined;
-    };
-    Uint16ArraySerializer.prototype.deserialize = function (x, serializerContext) {
-        if (isUndefined(x)) {
-            return serializerContext.deserializedDefaultValue;
-        }
-        if (isNull(x)) {
-            return serializerContext.deserializedNullValue;
-        }
-        if (isArray(x)) {
-            return Uint16Array.from(x);
-        }
-        if (serializerContext.log.errorEnabled) {
-            serializerContext.log.error("".concat(serializerContext.jsonPath, ": cannot deserialize value as uint 16 array."), x);
-        }
-        return undefined;
-    };
-    return Uint16ArraySerializer;
-}());
-export { Uint16ArraySerializer };
+import { isArray, isNull, isUndefined } from 'lodash';
+import { isUint16Array } from '../functions/is-uint-16-array';
+var Uint16ArraySerializer = (function () {
+    function Uint16ArraySerializer() {
+    }
+    Uint16ArraySerializer.prototype.serialize = function (x, serializerContext) {
+        if (isUndefined(x)) {
+            return serializerContext.serializedDefaultValue;
+        }
+        if (isNull(x)) {
+            return serializerContext.serializedNullValue;
+        }
+        if (isUint16Array(x)) {
+            return Array.from(x);
+        }
+        if (serializerContext.log.errorEnabled) {
+            serializerContext.log.error("".concat(serializerContext.jsonPath, ": cannot serialize value as uint 16 array."), x);
+        }
+        return undefined;
+    };
+    Uint16ArraySerializer.prototype.deserialize = function (x, serializerContext) {
+        if (isUndefined(x)) {
+            return serializerContext.deserializedDefaultValue;
+        }
+        if (isNull(x)) {
+            return serializerContext.deserializedNullValue;
+        }
+        if (isArray(x)) {
+            return Uint16Array.from(x);
+        }
+        if (serializerContext.log.errorEnabled) {
+            serializerContext.log.error("".concat(serializerContext.jsonPath, ": cannot deserialize value as uint 16 array."), x);
+        }
+        return undefined;
+    };
+    return Uint16ArraySerializer;
+}());
+export { Uint16ArraySerializer };
 //# sourceMappingURL=uint-16-array-serializer.js.map

package/dist/es5/serializers/uint-32-array-serializer.js

@@ -1,39 +1,39 @@
-import { isArray, isNull, isUndefined } from 'lodash';
-import { isUint32Array } from '../functions/is-uint-32-array';
-var Uint32ArraySerializer = (function () {
-    function Uint32ArraySerializer() {
-    }
-    Uint32ArraySerializer.prototype.serialize = function (x, serializerContext) {
-        if (isUndefined(x)) {
-            return serializerContext.serializedDefaultValue;
-        }
-        if (isNull(x)) {
-            return serializerContext.serializedNullValue;
-        }
-        if (isUint32Array(x)) {
-            return Array.from(x);
-        }
-        if (serializerContext.log.errorEnabled) {
-            serializerContext.log.error("".concat(serializerContext.jsonPath, ": cannot serialize value as uint 32 array."), x);
-        }
-        return undefined;
-    };
-    Uint32ArraySerializer.prototype.deserialize = function (x, serializerContext) {
-        if (isUndefined(x)) {
-            return serializerContext.deserializedDefaultValue;
-        }
-        if (isNull(x)) {
-            return serializerContext.deserializedNullValue;
-        }
-        if (isArray(x)) {
-            return Uint32Array.from(x);
-        }
-        if (serializerContext.log.errorEnabled) {
-            serializerContext.log.error("".concat(serializerContext.jsonPath, ": cannot deserialize value as uint 32 array."), x);
-        }
-        return undefined;
-    };
-    return Uint32ArraySerializer;
-}());
-export { Uint32ArraySerializer };
+import { isArray, isNull, isUndefined } from 'lodash';
+import { isUint32Array } from '../functions/is-uint-32-array';
+var Uint32ArraySerializer = (function () {
+    function Uint32ArraySerializer() {
+    }
+    Uint32ArraySerializer.prototype.serialize = function (x, serializerContext) {
+        if (isUndefined(x)) {
+            return serializerContext.serializedDefaultValue;
+        }
+        if (isNull(x)) {
+            return serializerContext.serializedNullValue;
+        }
+        if (isUint32Array(x)) {
+            return Array.from(x);
+        }
+        if (serializerContext.log.errorEnabled) {
+            serializerContext.log.error("".concat(serializerContext.jsonPath, ": cannot serialize value as uint 32 array."), x);
+        }
+        return undefined;
+    };
+    Uint32ArraySerializer.prototype.deserialize = function (x, serializerContext) {
+        if (isUndefined(x)) {
+            return serializerContext.deserializedDefaultValue;
+        }
+        if (isNull(x)) {
+            return serializerContext.deserializedNullValue;
+        }
+        if (isArray(x)) {
+            return Uint32Array.from(x);
+        }
+        if (serializerContext.log.errorEnabled) {
+            serializerContext.log.error("".concat(serializerContext.jsonPath, ": cannot deserialize value as uint 32 array."), x);
+        }
+        return undefined;
+    };
+    return Uint32ArraySerializer;
+}());
+export { Uint32ArraySerializer };
 //# sourceMappingURL=uint-32-array-serializer.js.map

package/dist/es5/serializers/uint-8-array-serializer.js

@@ -1,39 +1,39 @@
-import { isArray, isNull, isUndefined } from 'lodash';
-import { isUint8Array } from '../functions/is-uint-8-array';
-var Uint8ArraySerializer = (function () {
-    function Uint8ArraySerializer() {
-    }
-    Uint8ArraySerializer.prototype.serialize = function (x, serializerContext) {
-        if (isUndefined(x)) {
-            return serializerContext.serializedDefaultValue;
-        }
-        if (isNull(x)) {
-            return serializerContext.serializedNullValue;
-        }
-        if (isUint8Array(x)) {
-            return Array.from(x);
-        }
-        if (serializerContext.log.errorEnabled) {
-            serializerContext.log.error("".concat(serializerContext.jsonPath, ": cannot serialize value as uint 8 array."), x);
-        }
-        return undefined;
-    };
-    Uint8ArraySerializer.prototype.deserialize = function (x, serializerContext) {
-        if (isUndefined(x)) {
-            return serializerContext.deserializedDefaultValue;
-        }
-        if (isNull(x)) {
-            return serializerContext.deserializedNullValue;
-        }
-        if (isArray(x)) {
-            return Uint8Array.from(x);
-        }
-        if (serializerContext.log.errorEnabled) {
-            serializerContext.log.error("".concat(serializerContext.jsonPath, ": cannot deserialize value as uint 8 array."), x);
-        }
-        return undefined;
-    };
-    return Uint8ArraySerializer;
-}());
-export { Uint8ArraySerializer };
+import { isArray, isNull, isUndefined } from 'lodash';
+import { isUint8Array } from '../functions/is-uint-8-array';
+var Uint8ArraySerializer = (function () {
+    function Uint8ArraySerializer() {
+    }
+    Uint8ArraySerializer.prototype.serialize = function (x, serializerContext) {
+        if (isUndefined(x)) {
+            return serializerContext.serializedDefaultValue;
+        }
+        if (isNull(x)) {
+            return serializerContext.serializedNullValue;
+        }
+        if (isUint8Array(x)) {
+            return Array.from(x);
+        }
+        if (serializerContext.log.errorEnabled) {
+            serializerContext.log.error("".concat(serializerContext.jsonPath, ": cannot serialize value as uint 8 array."), x);
+        }
+        return undefined;
+    };
+    Uint8ArraySerializer.prototype.deserialize = function (x, serializerContext) {
+        if (isUndefined(x)) {
+            return serializerContext.deserializedDefaultValue;
+        }
+        if (isNull(x)) {
+            return serializerContext.deserializedNullValue;
+        }
+        if (isArray(x)) {
+            return Uint8Array.from(x);
+        }
+        if (serializerContext.log.errorEnabled) {
+            serializerContext.log.error("".concat(serializerContext.jsonPath, ": cannot deserialize value as uint 8 array."), x);
+        }
+        return undefined;
+    };
+    return Uint8ArraySerializer;
+}());
+export { Uint8ArraySerializer };
 //# sourceMappingURL=uint-8-array-serializer.js.map

package/dist/es5/serializers/uint-8-clamped-array-serializer.js

@@ -1,39 +1,39 @@
-import { isArray, isNull, isUndefined } from 'lodash';
-import { isUint8ClampedArray } from '../functions/is-uint-8-clamped-array';
-var Uint8ClampedArraySerializer = (function () {
-    function Uint8ClampedArraySerializer() {
-    }
-    Uint8ClampedArraySerializer.prototype.serialize = function (x, serializerContext) {
-        if (isUndefined(x)) {
-            return serializerContext.serializedDefaultValue;
-        }
-        if (isNull(x)) {
-            return serializerContext.serializedNullValue;
-        }
-        if (isUint8ClampedArray(x)) {
-            return Array.from(x);
-        }
-        if (serializerContext.log.errorEnabled) {
-            serializerContext.log.error("".concat(serializerContext.jsonPath, ": cannot serialize value as uint 8 clamped array."), x);
-        }
-        return undefined;
-    };
-    Uint8ClampedArraySerializer.prototype.deserialize = function (x, serializerContext) {
-        if (isUndefined(x)) {
-            return serializerContext.deserializedDefaultValue;
-        }
-        if (isNull(x)) {
-            return serializerContext.deserializedNullValue;
-        }
-        if (isArray(x)) {
-            return Uint8ClampedArray.from(x);
-        }
-        if (serializerContext.log.errorEnabled) {
-            serializerContext.log.error("".concat(serializerContext.jsonPath, ": cannot deserialize value as uint 8 clamped array."), x);
-        }
-        return undefined;
-    };
-    return Uint8ClampedArraySerializer;
-}());
-export { Uint8ClampedArraySerializer };
+import { isArray, isNull, isUndefined } from 'lodash';
+import { isUint8ClampedArray } from '../functions/is-uint-8-clamped-array';
+var Uint8ClampedArraySerializer = (function () {
+    function Uint8ClampedArraySerializer() {
+    }
+    Uint8ClampedArraySerializer.prototype.serialize = function (x, serializerContext) {
+        if (isUndefined(x)) {
+            return serializerContext.serializedDefaultValue;
+        }
+        if (isNull(x)) {
+            return serializerContext.serializedNullValue;
+        }
+        if (isUint8ClampedArray(x)) {
+            return Array.from(x);
+        }
+        if (serializerContext.log.errorEnabled) {
+            serializerContext.log.error("".concat(serializerContext.jsonPath, ": cannot serialize value as uint 8 clamped array."), x);
+        }
+        return undefined;
+    };
+    Uint8ClampedArraySerializer.prototype.deserialize = function (x, serializerContext) {
+        if (isUndefined(x)) {
+            return serializerContext.deserializedDefaultValue;
+        }
+        if (isNull(x)) {
+            return serializerContext.deserializedNullValue;
+        }
+        if (isArray(x)) {
+            return Uint8ClampedArray.from(x);
+        }
+        if (serializerContext.log.errorEnabled) {
+            serializerContext.log.error("".concat(serializerContext.jsonPath, ": cannot deserialize value as uint 8 clamped array."), x);
+        }
+        return undefined;
+    };
+    return Uint8ClampedArraySerializer;
+}());
+export { Uint8ClampedArraySerializer };
 //# sourceMappingURL=uint-8-clamped-array-serializer.js.map