@dipscope/type-manager 6.0.0 → 7.0.0

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

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

package/dist/es2015/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/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