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

package/dist/es5/serializers/float-64-array-serializer.js

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

package/dist/es5/serializers/index.js

@@ -1,22 +1,22 @@
-export * from './any-serializer';
-export * from './array-buffer-serializer';
-export * from './array-serializer';
-export * from './boolean-serializer';
-export * from './data-view-serializer';
-export * from './date-serializer';
-export * from './float-32-array-serializer';
-export * from './float-64-array-serializer';
-export * from './int-8-array-serializer';
-export * from './int-16-array-serializer';
-export * from './int-32-array-serializer';
-export * from './map-serializer';
-export * from './number-serializer';
-export * from './set-serializer';
-export * from './string-serializer';
-export * from './type-serializer';
-export * from './uint-8-array-serializer';
-export * from './uint-8-clamped-array-serializer';
-export * from './uint-16-array-serializer';
-export * from './uint-32-array-serializer';
-export * from './unknown-serializer';
+export * from './any-serializer';
+export * from './array-buffer-serializer';
+export * from './array-serializer';
+export * from './boolean-serializer';
+export * from './data-view-serializer';
+export * from './date-serializer';
+export * from './float-32-array-serializer';
+export * from './float-64-array-serializer';
+export * from './int-8-array-serializer';
+export * from './int-16-array-serializer';
+export * from './int-32-array-serializer';
+export * from './map-serializer';
+export * from './number-serializer';
+export * from './set-serializer';
+export * from './string-serializer';
+export * from './type-serializer';
+export * from './uint-8-array-serializer';
+export * from './uint-8-clamped-array-serializer';
+export * from './uint-16-array-serializer';
+export * from './uint-32-array-serializer';
+export * from './unknown-serializer';
 //# sourceMappingURL=index.js.map

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

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

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

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

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

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

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

@@ -1,115 +1,115 @@
-import { __read, __values } from "tslib";
-import { isArray, isMap, isNull, isUndefined } from 'lodash';
-var MapSerializer = (function () {
-    function MapSerializer() {
-    }
-    MapSerializer.prototype.serialize = function (x, serializerContext) {
-        if (isUndefined(x)) {
-            return serializerContext.serializedDefaultValue;
-        }
-        if (isNull(x)) {
-            return serializerContext.serializedNullValue;
-        }
-        if (isMap(x)) {
-            return serializerContext.defineReference(x, function () {
-                var e_1, _a;
-                var map = x;
-                var array = new Array(x.keys.length);
-                var genericKeySerializerContext = serializerContext.defineGenericSerializerContext(0);
-                var genericValueSerializerContext = serializerContext.defineGenericSerializerContext(1);
-                var keyArraySerializerContext = genericKeySerializerContext.defineChildSerializerContext({
-                    jsonPathKey: genericKeySerializerContext.jsonPathKey
-                });
-                var valueArraySerializerContext = genericValueSerializerContext.defineChildSerializerContext({
-                    jsonPathKey: genericValueSerializerContext.jsonPathKey
-                });
-                var keySerializerContext = keyArraySerializerContext.defineChildSerializerContext({
-                    jsonPathKey: 'key',
-                    typeMetadata: genericKeySerializerContext.typeMetadata
-                });
-                var valueSerializerContext = valueArraySerializerContext.defineChildSerializerContext({
-                    jsonPathKey: 'value',
-                    typeMetadata: genericValueSerializerContext.typeMetadata
-                });
-                var i = -1;
-                try {
-                    for (var _b = __values(map.entries()), _c = _b.next(); !_c.done; _c = _b.next()) {
-                        var _d = __read(_c.value, 2), mk = _d[0], mv = _d[1];
-                        i++;
-                        keyArraySerializerContext.hasJsonPathKey(i);
-                        valueArraySerializerContext.hasJsonPathKey(i);
-                        keySerializerContext.hasReferenceValueSetter(function (v) { return array[i][keySerializerContext.jsonPathKey] = v; });
-                        valueSerializerContext.hasReferenceValueSetter(function (v) { return array[i][valueSerializerContext.jsonPathKey] = v; });
-                        array[i] = {};
-                        array[i][keySerializerContext.jsonPathKey] = keySerializerContext.serialize(mk);
-                        array[i][valueSerializerContext.jsonPathKey] = valueSerializerContext.serialize(mv);
-                    }
-                }
-                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 array;
-            });
-        }
-        if (serializerContext.log.errorEnabled) {
-            serializerContext.log.error("".concat(serializerContext.jsonPath, ": cannot serialize value as map."), x);
-        }
-        return undefined;
-    };
-    MapSerializer.prototype.deserialize = function (x, serializerContext) {
-        if (isUndefined(x)) {
-            return serializerContext.deserializedDefaultValue;
-        }
-        if (isNull(x)) {
-            return serializerContext.deserializedNullValue;
-        }
-        if (isArray(x)) {
-            return serializerContext.restoreReference(x, function () {
-                var array = x;
-                var map = new Map();
-                var genericKeySerializerContext = serializerContext.defineGenericSerializerContext(0);
-                var genericValueSerializerContext = serializerContext.defineGenericSerializerContext(1);
-                var keyArraySerializerContext = genericKeySerializerContext.defineChildSerializerContext({
-                    jsonPathKey: genericKeySerializerContext.jsonPathKey
-                });
-                var valueArraySerializerContext = genericValueSerializerContext.defineChildSerializerContext({
-                    jsonPathKey: genericValueSerializerContext.jsonPathKey
-                });
-                var keySerializerContext = keyArraySerializerContext.defineChildSerializerContext({
-                    jsonPathKey: 'key',
-                    typeMetadata: genericKeySerializerContext.typeMetadata
-                });
-                var valueSerializerContext = valueArraySerializerContext.defineChildSerializerContext({
-                    jsonPathKey: 'value',
-                    typeMetadata: genericValueSerializerContext.typeMetadata
-                });
-                var _loop_1 = function (i) {
-                    var mk = array[i][keySerializerContext.jsonPathKey];
-                    var mv = array[i][valueSerializerContext.jsonPathKey];
-                    keyArraySerializerContext.hasJsonPathKey(i);
-                    valueArraySerializerContext.hasJsonPathKey(i);
-                    keySerializerContext.hasReferenceValueSetter(function (v) { return map.set(v, undefined); });
-                    var key = keySerializerContext.deserialize(mk);
-                    valueSerializerContext.hasReferenceValueSetter(function (v) { return map.set(key, v); });
-                    var value = valueSerializerContext.deserialize(mv);
-                    map.set(key, value);
-                };
-                for (var i = 0; i < array.length; i++) {
-                    _loop_1(i);
-                }
-                return map;
-            });
-        }
-        if (serializerContext.log.errorEnabled) {
-            serializerContext.log.error("".concat(serializerContext.jsonPath, ": Cannot deserialize value as map!"), x);
-        }
-        return undefined;
-    };
-    return MapSerializer;
-}());
-export { MapSerializer };
+import { __read, __values } from "tslib";
+import { isArray, isMap, isNull, isUndefined } from 'lodash';
+var MapSerializer = (function () {
+    function MapSerializer() {
+    }
+    MapSerializer.prototype.serialize = function (x, serializerContext) {
+        if (isUndefined(x)) {
+            return serializerContext.serializedDefaultValue;
+        }
+        if (isNull(x)) {
+            return serializerContext.serializedNullValue;
+        }
+        if (isMap(x)) {
+            return serializerContext.defineReference(x, function () {
+                var e_1, _a;
+                var map = x;
+                var array = new Array(x.keys.length);
+                var genericKeySerializerContext = serializerContext.defineGenericSerializerContext(0);
+                var genericValueSerializerContext = serializerContext.defineGenericSerializerContext(1);
+                var keyArraySerializerContext = genericKeySerializerContext.defineChildSerializerContext({
+                    jsonPathKey: genericKeySerializerContext.jsonPathKey
+                });
+                var valueArraySerializerContext = genericValueSerializerContext.defineChildSerializerContext({
+                    jsonPathKey: genericValueSerializerContext.jsonPathKey
+                });
+                var keySerializerContext = keyArraySerializerContext.defineChildSerializerContext({
+                    jsonPathKey: 'key',
+                    typeMetadata: genericKeySerializerContext.typeMetadata
+                });
+                var valueSerializerContext = valueArraySerializerContext.defineChildSerializerContext({
+                    jsonPathKey: 'value',
+                    typeMetadata: genericValueSerializerContext.typeMetadata
+                });
+                var i = -1;
+                try {
+                    for (var _b = __values(map.entries()), _c = _b.next(); !_c.done; _c = _b.next()) {
+                        var _d = __read(_c.value, 2), mk = _d[0], mv = _d[1];
+                        i++;
+                        keyArraySerializerContext.hasJsonPathKey(i);
+                        valueArraySerializerContext.hasJsonPathKey(i);
+                        keySerializerContext.hasReferenceValueSetter(function (v) { return array[i][keySerializerContext.jsonPathKey] = v; });
+                        valueSerializerContext.hasReferenceValueSetter(function (v) { return array[i][valueSerializerContext.jsonPathKey] = v; });
+                        array[i] = {};
+                        array[i][keySerializerContext.jsonPathKey] = keySerializerContext.serialize(mk);
+                        array[i][valueSerializerContext.jsonPathKey] = valueSerializerContext.serialize(mv);
+                    }
+                }
+                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 array;
+            });
+        }
+        if (serializerContext.log.errorEnabled) {
+            serializerContext.log.error("".concat(serializerContext.jsonPath, ": cannot serialize value as map."), x);
+        }
+        return undefined;
+    };
+    MapSerializer.prototype.deserialize = function (x, serializerContext) {
+        if (isUndefined(x)) {
+            return serializerContext.deserializedDefaultValue;
+        }
+        if (isNull(x)) {
+            return serializerContext.deserializedNullValue;
+        }
+        if (isArray(x)) {
+            return serializerContext.restoreReference(x, function () {
+                var array = x;
+                var map = new Map();
+                var genericKeySerializerContext = serializerContext.defineGenericSerializerContext(0);
+                var genericValueSerializerContext = serializerContext.defineGenericSerializerContext(1);
+                var keyArraySerializerContext = genericKeySerializerContext.defineChildSerializerContext({
+                    jsonPathKey: genericKeySerializerContext.jsonPathKey
+                });
+                var valueArraySerializerContext = genericValueSerializerContext.defineChildSerializerContext({
+                    jsonPathKey: genericValueSerializerContext.jsonPathKey
+                });
+                var keySerializerContext = keyArraySerializerContext.defineChildSerializerContext({
+                    jsonPathKey: 'key',
+                    typeMetadata: genericKeySerializerContext.typeMetadata
+                });
+                var valueSerializerContext = valueArraySerializerContext.defineChildSerializerContext({
+                    jsonPathKey: 'value',
+                    typeMetadata: genericValueSerializerContext.typeMetadata
+                });
+                var _loop_1 = function (i) {
+                    var mk = array[i][keySerializerContext.jsonPathKey];
+                    var mv = array[i][valueSerializerContext.jsonPathKey];
+                    keyArraySerializerContext.hasJsonPathKey(i);
+                    valueArraySerializerContext.hasJsonPathKey(i);
+                    keySerializerContext.hasReferenceValueSetter(function (v) { return map.set(v, undefined); });
+                    var key = keySerializerContext.deserialize(mk);
+                    valueSerializerContext.hasReferenceValueSetter(function (v) { return map.set(key, v); });
+                    var value = valueSerializerContext.deserialize(mv);
+                    map.set(key, value);
+                };
+                for (var i = 0; i < array.length; i++) {
+                    _loop_1(i);
+                }
+                return map;
+            });
+        }
+        if (serializerContext.log.errorEnabled) {
+            serializerContext.log.error("".concat(serializerContext.jsonPath, ": Cannot deserialize value as map!"), x);
+        }
+        return undefined;
+    };
+    return MapSerializer;
+}());
+export { MapSerializer };
 //# sourceMappingURL=map-serializer.js.map