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

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

@@ -1,35 +1,35 @@
-import { isArray, isNull, isUndefined } from 'lodash';
-import { isInt16Array } from '../functions/is-int-16-array';
-export class Int16ArraySerializer {
-    serialize(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(`${serializerContext.jsonPath}: cannot serialize value as int 16 array.`, x);
-        }
-        return undefined;
-    }
-    deserialize(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(`${serializerContext.jsonPath}: cannot deserialize value as int 16 array.`, x);
-        }
-        return undefined;
-    }
-}
+import { isArray, isNull, isUndefined } from 'lodash';
+import { isInt16Array } from '../functions/is-int-16-array';
+export class Int16ArraySerializer {
+    serialize(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(`${serializerContext.jsonPath}: cannot serialize value as int 16 array.`, x);
+        }
+        return undefined;
+    }
+    deserialize(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(`${serializerContext.jsonPath}: cannot deserialize value as int 16 array.`, x);
+        }
+        return undefined;
+    }
+}
 //# sourceMappingURL=int-16-array-serializer.js.map

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

@@ -1,35 +1,35 @@
-import { isArray, isNull, isUndefined } from 'lodash';
-import { isInt32Array } from '../functions/is-int-32-array';
-export class Int32ArraySerializer {
-    serialize(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(`${serializerContext.jsonPath}: cannot serialize value as int 32 array.`, x);
-        }
-        return undefined;
-    }
-    deserialize(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(`${serializerContext.jsonPath}: cannot deserialize value as int 32 array.`, x);
-        }
-        return undefined;
-    }
-}
+import { isArray, isNull, isUndefined } from 'lodash';
+import { isInt32Array } from '../functions/is-int-32-array';
+export class Int32ArraySerializer {
+    serialize(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(`${serializerContext.jsonPath}: cannot serialize value as int 32 array.`, x);
+        }
+        return undefined;
+    }
+    deserialize(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(`${serializerContext.jsonPath}: cannot deserialize value as int 32 array.`, x);
+        }
+        return undefined;
+    }
+}
 //# sourceMappingURL=int-32-array-serializer.js.map

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

@@ -1,35 +1,35 @@
-import { isArray, isNull, isUndefined } from 'lodash';
-import { isInt8Array } from '../functions/is-int-8-array';
-export class Int8ArraySerializer {
-    serialize(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(`${serializerContext.jsonPath}: cannot serialize value as int 8 array.`, x);
-        }
-        return undefined;
-    }
-    deserialize(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(`${serializerContext.jsonPath}: cannot deserialize value as int 8 array.`, x);
-        }
-        return undefined;
-    }
-}
+import { isArray, isNull, isUndefined } from 'lodash';
+import { isInt8Array } from '../functions/is-int-8-array';
+export class Int8ArraySerializer {
+    serialize(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(`${serializerContext.jsonPath}: cannot serialize value as int 8 array.`, x);
+        }
+        return undefined;
+    }
+    deserialize(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(`${serializerContext.jsonPath}: cannot deserialize value as int 8 array.`, x);
+        }
+        return undefined;
+    }
+}
 //# sourceMappingURL=int-8-array-serializer.js.map

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

@@ -1,96 +1,96 @@
-import { isArray, isMap, isNull, isUndefined } from 'lodash';
-export class MapSerializer {
-    serialize(x, serializerContext) {
-        if (isUndefined(x)) {
-            return serializerContext.serializedDefaultValue;
-        }
-        if (isNull(x)) {
-            return serializerContext.serializedNullValue;
-        }
-        if (isMap(x)) {
-            return serializerContext.defineReference(x, () => {
-                const map = x;
-                const array = new Array(x.keys.length);
-                const genericKeySerializerContext = serializerContext.defineGenericSerializerContext(0);
-                const genericValueSerializerContext = serializerContext.defineGenericSerializerContext(1);
-                const keyArraySerializerContext = genericKeySerializerContext.defineChildSerializerContext({
-                    jsonPathKey: genericKeySerializerContext.jsonPathKey
-                });
-                const valueArraySerializerContext = genericValueSerializerContext.defineChildSerializerContext({
-                    jsonPathKey: genericValueSerializerContext.jsonPathKey
-                });
-                const keySerializerContext = keyArraySerializerContext.defineChildSerializerContext({
-                    jsonPathKey: 'key',
-                    typeMetadata: genericKeySerializerContext.typeMetadata
-                });
-                const valueSerializerContext = valueArraySerializerContext.defineChildSerializerContext({
-                    jsonPathKey: 'value',
-                    typeMetadata: genericValueSerializerContext.typeMetadata
-                });
-                let i = -1;
-                for (const [mk, mv] of map.entries()) {
-                    i++;
-                    keyArraySerializerContext.hasJsonPathKey(i);
-                    valueArraySerializerContext.hasJsonPathKey(i);
-                    keySerializerContext.hasReferenceValueSetter(v => array[i][keySerializerContext.jsonPathKey] = v);
-                    valueSerializerContext.hasReferenceValueSetter(v => array[i][valueSerializerContext.jsonPathKey] = v);
-                    array[i] = {};
-                    array[i][keySerializerContext.jsonPathKey] = keySerializerContext.serialize(mk);
-                    array[i][valueSerializerContext.jsonPathKey] = valueSerializerContext.serialize(mv);
-                }
-                return array;
-            });
-        }
-        if (serializerContext.log.errorEnabled) {
-            serializerContext.log.error(`${serializerContext.jsonPath}: cannot serialize value as map.`, x);
-        }
-        return undefined;
-    }
-    deserialize(x, serializerContext) {
-        if (isUndefined(x)) {
-            return serializerContext.deserializedDefaultValue;
-        }
-        if (isNull(x)) {
-            return serializerContext.deserializedNullValue;
-        }
-        if (isArray(x)) {
-            return serializerContext.restoreReference(x, () => {
-                const array = x;
-                const map = new Map();
-                const genericKeySerializerContext = serializerContext.defineGenericSerializerContext(0);
-                const genericValueSerializerContext = serializerContext.defineGenericSerializerContext(1);
-                const keyArraySerializerContext = genericKeySerializerContext.defineChildSerializerContext({
-                    jsonPathKey: genericKeySerializerContext.jsonPathKey
-                });
-                const valueArraySerializerContext = genericValueSerializerContext.defineChildSerializerContext({
-                    jsonPathKey: genericValueSerializerContext.jsonPathKey
-                });
-                const keySerializerContext = keyArraySerializerContext.defineChildSerializerContext({
-                    jsonPathKey: 'key',
-                    typeMetadata: genericKeySerializerContext.typeMetadata
-                });
-                const valueSerializerContext = valueArraySerializerContext.defineChildSerializerContext({
-                    jsonPathKey: 'value',
-                    typeMetadata: genericValueSerializerContext.typeMetadata
-                });
-                for (let i = 0; i < array.length; i++) {
-                    const mk = array[i][keySerializerContext.jsonPathKey];
-                    const mv = array[i][valueSerializerContext.jsonPathKey];
-                    keyArraySerializerContext.hasJsonPathKey(i);
-                    valueArraySerializerContext.hasJsonPathKey(i);
-                    keySerializerContext.hasReferenceValueSetter(v => map.set(v, undefined));
-                    const key = keySerializerContext.deserialize(mk);
-                    valueSerializerContext.hasReferenceValueSetter(v => map.set(key, v));
-                    const value = valueSerializerContext.deserialize(mv);
-                    map.set(key, value);
-                }
-                return map;
-            });
-        }
-        if (serializerContext.log.errorEnabled) {
-            serializerContext.log.error(`${serializerContext.jsonPath}: Cannot deserialize value as map!`, x);
-        }
-        return undefined;
-    }
-}
+import { isArray, isMap, isNull, isUndefined } from 'lodash';
+export class MapSerializer {
+    serialize(x, serializerContext) {
+        if (isUndefined(x)) {
+            return serializerContext.serializedDefaultValue;
+        }
+        if (isNull(x)) {
+            return serializerContext.serializedNullValue;
+        }
+        if (isMap(x)) {
+            return serializerContext.defineReference(x, () => {
+                const map = x;
+                const array = new Array(x.keys.length);
+                const genericKeySerializerContext = serializerContext.defineGenericSerializerContext(0);
+                const genericValueSerializerContext = serializerContext.defineGenericSerializerContext(1);
+                const keyArraySerializerContext = genericKeySerializerContext.defineChildSerializerContext({
+                    jsonPathKey: genericKeySerializerContext.jsonPathKey
+                });
+                const valueArraySerializerContext = genericValueSerializerContext.defineChildSerializerContext({
+                    jsonPathKey: genericValueSerializerContext.jsonPathKey
+                });
+                const keySerializerContext = keyArraySerializerContext.defineChildSerializerContext({
+                    jsonPathKey: 'key',
+                    typeMetadata: genericKeySerializerContext.typeMetadata
+                });
+                const valueSerializerContext = valueArraySerializerContext.defineChildSerializerContext({
+                    jsonPathKey: 'value',
+                    typeMetadata: genericValueSerializerContext.typeMetadata
+                });
+                let i = -1;
+                for (const [mk, mv] of map.entries()) {
+                    i++;
+                    keyArraySerializerContext.hasJsonPathKey(i);
+                    valueArraySerializerContext.hasJsonPathKey(i);
+                    keySerializerContext.hasReferenceValueSetter(v => array[i][keySerializerContext.jsonPathKey] = v);
+                    valueSerializerContext.hasReferenceValueSetter(v => array[i][valueSerializerContext.jsonPathKey] = v);
+                    array[i] = {};
+                    array[i][keySerializerContext.jsonPathKey] = keySerializerContext.serialize(mk);
+                    array[i][valueSerializerContext.jsonPathKey] = valueSerializerContext.serialize(mv);
+                }
+                return array;
+            });
+        }
+        if (serializerContext.log.errorEnabled) {
+            serializerContext.log.error(`${serializerContext.jsonPath}: cannot serialize value as map.`, x);
+        }
+        return undefined;
+    }
+    deserialize(x, serializerContext) {
+        if (isUndefined(x)) {
+            return serializerContext.deserializedDefaultValue;
+        }
+        if (isNull(x)) {
+            return serializerContext.deserializedNullValue;
+        }
+        if (isArray(x)) {
+            return serializerContext.restoreReference(x, () => {
+                const array = x;
+                const map = new Map();
+                const genericKeySerializerContext = serializerContext.defineGenericSerializerContext(0);
+                const genericValueSerializerContext = serializerContext.defineGenericSerializerContext(1);
+                const keyArraySerializerContext = genericKeySerializerContext.defineChildSerializerContext({
+                    jsonPathKey: genericKeySerializerContext.jsonPathKey
+                });
+                const valueArraySerializerContext = genericValueSerializerContext.defineChildSerializerContext({
+                    jsonPathKey: genericValueSerializerContext.jsonPathKey
+                });
+                const keySerializerContext = keyArraySerializerContext.defineChildSerializerContext({
+                    jsonPathKey: 'key',
+                    typeMetadata: genericKeySerializerContext.typeMetadata
+                });
+                const valueSerializerContext = valueArraySerializerContext.defineChildSerializerContext({
+                    jsonPathKey: 'value',
+                    typeMetadata: genericValueSerializerContext.typeMetadata
+                });
+                for (let i = 0; i < array.length; i++) {
+                    const mk = array[i][keySerializerContext.jsonPathKey];
+                    const mv = array[i][valueSerializerContext.jsonPathKey];
+                    keyArraySerializerContext.hasJsonPathKey(i);
+                    valueArraySerializerContext.hasJsonPathKey(i);
+                    keySerializerContext.hasReferenceValueSetter(v => map.set(v, undefined));
+                    const key = keySerializerContext.deserialize(mk);
+                    valueSerializerContext.hasReferenceValueSetter(v => map.set(key, v));
+                    const value = valueSerializerContext.deserialize(mv);
+                    map.set(key, value);
+                }
+                return map;
+            });
+        }
+        if (serializerContext.log.errorEnabled) {
+            serializerContext.log.error(`${serializerContext.jsonPath}: Cannot deserialize value as map!`, x);
+        }
+        return undefined;
+    }
+}
 //# sourceMappingURL=map-serializer.js.map

package/dist/es2015/serializers/number-serializer.js

@@ -1,49 +1,49 @@
-import { isBoolean, isNull, isNumber, isString, isUndefined } from 'lodash';
-export class NumberSerializer {
-    serialize(x, serializerContext) {
-        if (isUndefined(x)) {
-            return serializerContext.serializedDefaultValue;
-        }
-        if (isNull(x)) {
-            return serializerContext.serializedNullValue;
-        }
-        if (isNumber(x)) {
-            return x;
-        }
-        if (serializerContext.useImplicitConversion) {
-            return this.convert(x, serializerContext);
-        }
-        if (serializerContext.log.errorEnabled) {
-            serializerContext.log.error(`${serializerContext.jsonPath}: cannot serialize value as number.`, x);
-        }
-        return undefined;
-    }
-    deserialize(x, serializerContext) {
-        if (isUndefined(x)) {
-            return serializerContext.deserializedDefaultValue;
-        }
-        if (isNull(x)) {
-            return serializerContext.deserializedNullValue;
-        }
-        if (isNumber(x)) {
-            return x;
-        }
-        if (serializerContext.useImplicitConversion) {
-            return this.convert(x, serializerContext);
-        }
-        if (serializerContext.log.errorEnabled) {
-            serializerContext.log.error(`${serializerContext.jsonPath}: cannot deserialize value as number.`, x);
-        }
-        return undefined;
-    }
-    convert(x, serializerContext) {
-        if (isString(x) || isBoolean(x)) {
-            return Number(x);
-        }
-        if (serializerContext.log.errorEnabled) {
-            serializerContext.log.error(`${serializerContext.jsonPath}: cannot convert value to a number.`, x);
-        }
-        return undefined;
-    }
-}
+import { isBoolean, isNull, isNumber, isString, isUndefined } from 'lodash';
+export class NumberSerializer {
+    serialize(x, serializerContext) {
+        if (isUndefined(x)) {
+            return serializerContext.serializedDefaultValue;
+        }
+        if (isNull(x)) {
+            return serializerContext.serializedNullValue;
+        }
+        if (isNumber(x)) {
+            return x;
+        }
+        if (serializerContext.useImplicitConversion) {
+            return this.convert(x, serializerContext);
+        }
+        if (serializerContext.log.errorEnabled) {
+            serializerContext.log.error(`${serializerContext.jsonPath}: cannot serialize value as number.`, x);
+        }
+        return undefined;
+    }
+    deserialize(x, serializerContext) {
+        if (isUndefined(x)) {
+            return serializerContext.deserializedDefaultValue;
+        }
+        if (isNull(x)) {
+            return serializerContext.deserializedNullValue;
+        }
+        if (isNumber(x)) {
+            return x;
+        }
+        if (serializerContext.useImplicitConversion) {
+            return this.convert(x, serializerContext);
+        }
+        if (serializerContext.log.errorEnabled) {
+            serializerContext.log.error(`${serializerContext.jsonPath}: cannot deserialize value as number.`, x);
+        }
+        return undefined;
+    }
+    convert(x, serializerContext) {
+        if (isString(x) || isBoolean(x)) {
+            return Number(x);
+        }
+        if (serializerContext.log.errorEnabled) {
+            serializerContext.log.error(`${serializerContext.jsonPath}: cannot convert value to a number.`, x);
+        }
+        return undefined;
+    }
+}
 //# sourceMappingURL=number-serializer.js.map

package/dist/es2015/serializers/set-serializer.js

@@ -1,62 +1,62 @@
-import { isArray, isNull, isSet, isUndefined } from 'lodash';
-export class SetSerializer {
-    serialize(x, serializerContext) {
-        if (isUndefined(x)) {
-            return serializerContext.serializedDefaultValue;
-        }
-        if (isNull(x)) {
-            return serializerContext.serializedNullValue;
-        }
-        if (isSet(x)) {
-            return serializerContext.defineReference(x, () => {
-                const set = x;
-                const array = new Array();
-                const genericSerializerContext = serializerContext.defineGenericSerializerContext(0);
-                const valueSerializerContext = genericSerializerContext.defineChildSerializerContext({
-                    jsonPathKey: genericSerializerContext.jsonPathKey
-                });
-                let i = -1;
-                for (const v of set) {
-                    i++;
-                    valueSerializerContext.hasJsonPathKey(i);
-                    valueSerializerContext.hasReferenceValueSetter(v => array[i] = v);
-                    array[i] = valueSerializerContext.serialize(v);
-                }
-                return array;
-            });
-        }
-        if (serializerContext.log.errorEnabled) {
-            serializerContext.log.error(`${serializerContext.jsonPath}: cannot serialize value as set.`, x);
-        }
-        return undefined;
-    }
-    deserialize(x, serializerContext) {
-        if (isUndefined(x)) {
-            return serializerContext.deserializedDefaultValue;
-        }
-        if (isNull(x)) {
-            return serializerContext.deserializedNullValue;
-        }
-        if (isArray(x)) {
-            return serializerContext.restoreReference(x, () => {
-                const array = x;
-                const set = new Set();
-                const genericSerializerContext = serializerContext.defineGenericSerializerContext(0);
-                const valueSerializerContext = genericSerializerContext.defineChildSerializerContext({
-                    jsonPathKey: genericSerializerContext.jsonPathKey
-                });
-                for (let i = 0; i < array.length; i++) {
-                    valueSerializerContext.hasJsonPathKey(i);
-                    valueSerializerContext.hasReferenceValueSetter(v => set.add(v));
-                    set.add(valueSerializerContext.deserialize(array[i]));
-                }
-                return set;
-            });
-        }
-        if (serializerContext.log.errorEnabled) {
-            serializerContext.log.error(`${serializerContext.jsonPath}: cannot deserialize value as set.`, x);
-        }
-        return undefined;
-    }
-}
+import { isArray, isNull, isSet, isUndefined } from 'lodash';
+export class SetSerializer {
+    serialize(x, serializerContext) {
+        if (isUndefined(x)) {
+            return serializerContext.serializedDefaultValue;
+        }
+        if (isNull(x)) {
+            return serializerContext.serializedNullValue;
+        }
+        if (isSet(x)) {
+            return serializerContext.defineReference(x, () => {
+                const set = x;
+                const array = new Array();
+                const genericSerializerContext = serializerContext.defineGenericSerializerContext(0);
+                const valueSerializerContext = genericSerializerContext.defineChildSerializerContext({
+                    jsonPathKey: genericSerializerContext.jsonPathKey
+                });
+                let i = -1;
+                for (const v of set) {
+                    i++;
+                    valueSerializerContext.hasJsonPathKey(i);
+                    valueSerializerContext.hasReferenceValueSetter(v => array[i] = v);
+                    array[i] = valueSerializerContext.serialize(v);
+                }
+                return array;
+            });
+        }
+        if (serializerContext.log.errorEnabled) {
+            serializerContext.log.error(`${serializerContext.jsonPath}: cannot serialize value as set.`, x);
+        }
+        return undefined;
+    }
+    deserialize(x, serializerContext) {
+        if (isUndefined(x)) {
+            return serializerContext.deserializedDefaultValue;
+        }
+        if (isNull(x)) {
+            return serializerContext.deserializedNullValue;
+        }
+        if (isArray(x)) {
+            return serializerContext.restoreReference(x, () => {
+                const array = x;
+                const set = new Set();
+                const genericSerializerContext = serializerContext.defineGenericSerializerContext(0);
+                const valueSerializerContext = genericSerializerContext.defineChildSerializerContext({
+                    jsonPathKey: genericSerializerContext.jsonPathKey
+                });
+                for (let i = 0; i < array.length; i++) {
+                    valueSerializerContext.hasJsonPathKey(i);
+                    valueSerializerContext.hasReferenceValueSetter(v => set.add(v));
+                    set.add(valueSerializerContext.deserialize(array[i]));
+                }
+                return set;
+            });
+        }
+        if (serializerContext.log.errorEnabled) {
+            serializerContext.log.error(`${serializerContext.jsonPath}: cannot deserialize value as set.`, x);
+        }
+        return undefined;
+    }
+}
 //# sourceMappingURL=set-serializer.js.map