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

package/dist/es2015/serializers/array-buffer-serializer.js

@@ -1,41 +1,41 @@
-import { isArrayBuffer, isNull, isString, isUndefined } from 'lodash';
-export class ArrayBufferSerializer {
-    serialize(x, serializerContext) {
-        if (isUndefined(x)) {
-            return serializerContext.serializedDefaultValue;
-        }
-        if (isNull(x)) {
-            return serializerContext.serializedNullValue;
-        }
-        if (isArrayBuffer(x)) {
-            const arrayBufferView = new Uint16Array(x);
-            const charCodeArray = Array.from(arrayBufferView);
-            return charCodeArray.map(c => String.fromCharCode(c)).join('');
-        }
-        if (serializerContext.log.errorEnabled) {
-            serializerContext.log.error(`${serializerContext.jsonPath}: cannot serialize value as array buffer.`, x);
-        }
-        return undefined;
-    }
-    deserialize(x, serializerContext) {
-        if (isUndefined(x)) {
-            return serializerContext.deserializedDefaultValue;
-        }
-        if (isNull(x)) {
-            return serializerContext.deserializedNullValue;
-        }
-        if (isString(x)) {
-            const arrayBuffer = new ArrayBuffer(x.length * 2);
-            const arrayBufferView = new Uint16Array(arrayBuffer);
-            for (let i = 0; i < x.length; i++) {
-                arrayBufferView[i] = x.charCodeAt(i);
-            }
-            return arrayBuffer;
-        }
-        if (serializerContext.log.errorEnabled) {
-            serializerContext.log.error(`${serializerContext.jsonPath}: cannot deserialize value as array buffer.`, x);
-        }
-        return undefined;
-    }
-}
+import { isArrayBuffer, isNull, isString, isUndefined } from 'lodash';
+export class ArrayBufferSerializer {
+    serialize(x, serializerContext) {
+        if (isUndefined(x)) {
+            return serializerContext.serializedDefaultValue;
+        }
+        if (isNull(x)) {
+            return serializerContext.serializedNullValue;
+        }
+        if (isArrayBuffer(x)) {
+            const arrayBufferView = new Uint16Array(x);
+            const charCodeArray = Array.from(arrayBufferView);
+            return charCodeArray.map(c => String.fromCharCode(c)).join('');
+        }
+        if (serializerContext.log.errorEnabled) {
+            serializerContext.log.error(`${serializerContext.jsonPath}: cannot serialize value as array buffer.`, x);
+        }
+        return undefined;
+    }
+    deserialize(x, serializerContext) {
+        if (isUndefined(x)) {
+            return serializerContext.deserializedDefaultValue;
+        }
+        if (isNull(x)) {
+            return serializerContext.deserializedNullValue;
+        }
+        if (isString(x)) {
+            const arrayBuffer = new ArrayBuffer(x.length * 2);
+            const arrayBufferView = new Uint16Array(arrayBuffer);
+            for (let i = 0; i < x.length; i++) {
+                arrayBufferView[i] = x.charCodeAt(i);
+            }
+            return arrayBuffer;
+        }
+        if (serializerContext.log.errorEnabled) {
+            serializerContext.log.error(`${serializerContext.jsonPath}: cannot deserialize value as array buffer.`, x);
+        }
+        return undefined;
+    }
+}
 //# sourceMappingURL=array-buffer-serializer.js.map

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

@@ -1,60 +1,60 @@
-import { isArray, isNull, isUndefined } from 'lodash';
-export class ArraySerializer {
-    serialize(x, serializerContext) {
-        if (isUndefined(x)) {
-            return serializerContext.serializedDefaultValue;
-        }
-        if (isNull(x)) {
-            return serializerContext.serializedNullValue;
-        }
-        if (isArray(x)) {
-            return serializerContext.defineReference(x, () => {
-                const arrayInput = x;
-                const arrayOutput = new Array(x.length);
-                const genericSerializerContext = serializerContext.defineGenericSerializerContext(0);
-                const valueSerializerContext = genericSerializerContext.defineChildSerializerContext({
-                    jsonPathKey: genericSerializerContext.jsonPathKey
-                });
-                for (let i = 0; i < arrayInput.length; i++) {
-                    valueSerializerContext.hasJsonPathKey(i);
-                    valueSerializerContext.hasReferenceValueSetter(v => arrayOutput[i] = v);
-                    arrayOutput[i] = valueSerializerContext.serialize(arrayInput[i]);
-                }
-                return arrayOutput;
-            });
-        }
-        if (serializerContext.log.errorEnabled) {
-            serializerContext.log.error(`${serializerContext.jsonPath}: cannot serialize value as array.`, 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 arrayInput = x;
-                const arrayOutput = new Array(x.length);
-                const genericSerializerContext = serializerContext.defineGenericSerializerContext(0);
-                const valueSerializerContext = genericSerializerContext.defineChildSerializerContext({
-                    jsonPathKey: genericSerializerContext.jsonPathKey
-                });
-                for (let i = 0; i < arrayInput.length; i++) {
-                    valueSerializerContext.hasJsonPathKey(i);
-                    valueSerializerContext.hasReferenceValueSetter(v => arrayOutput[i] = v);
-                    arrayOutput[i] = valueSerializerContext.deserialize(arrayInput[i]);
-                }
-                return arrayOutput;
-            });
-        }
-        if (serializerContext.log.errorEnabled) {
-            serializerContext.log.error(`${serializerContext.jsonPath}: cannot deserialize value as array.`, x);
-        }
-        return undefined;
-    }
-}
+import { isArray, isNull, isUndefined } from 'lodash';
+export class ArraySerializer {
+    serialize(x, serializerContext) {
+        if (isUndefined(x)) {
+            return serializerContext.serializedDefaultValue;
+        }
+        if (isNull(x)) {
+            return serializerContext.serializedNullValue;
+        }
+        if (isArray(x)) {
+            return serializerContext.defineReference(x, () => {
+                const arrayInput = x;
+                const arrayOutput = new Array(x.length);
+                const genericSerializerContext = serializerContext.defineGenericSerializerContext(0);
+                const valueSerializerContext = genericSerializerContext.defineChildSerializerContext({
+                    jsonPathKey: genericSerializerContext.jsonPathKey
+                });
+                for (let i = 0; i < arrayInput.length; i++) {
+                    valueSerializerContext.hasJsonPathKey(i);
+                    valueSerializerContext.hasReferenceValueSetter(v => arrayOutput[i] = v);
+                    arrayOutput[i] = valueSerializerContext.serialize(arrayInput[i]);
+                }
+                return arrayOutput;
+            });
+        }
+        if (serializerContext.log.errorEnabled) {
+            serializerContext.log.error(`${serializerContext.jsonPath}: cannot serialize value as array.`, 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 arrayInput = x;
+                const arrayOutput = new Array(x.length);
+                const genericSerializerContext = serializerContext.defineGenericSerializerContext(0);
+                const valueSerializerContext = genericSerializerContext.defineChildSerializerContext({
+                    jsonPathKey: genericSerializerContext.jsonPathKey
+                });
+                for (let i = 0; i < arrayInput.length; i++) {
+                    valueSerializerContext.hasJsonPathKey(i);
+                    valueSerializerContext.hasReferenceValueSetter(v => arrayOutput[i] = v);
+                    arrayOutput[i] = valueSerializerContext.deserialize(arrayInput[i]);
+                }
+                return arrayOutput;
+            });
+        }
+        if (serializerContext.log.errorEnabled) {
+            serializerContext.log.error(`${serializerContext.jsonPath}: cannot deserialize value as array.`, x);
+        }
+        return undefined;
+    }
+}
 //# sourceMappingURL=array-serializer.js.map

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

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

package/dist/es2015/serializers/data-view-serializer.js

@@ -1,42 +1,42 @@
-import { isNull, isString, isUndefined } from 'lodash';
-import { isDataView } from '../functions/is-data-view';
-export class DataViewSerializer {
-    serialize(x, serializerContext) {
-        if (isUndefined(x)) {
-            return serializerContext.serializedDefaultValue;
-        }
-        if (isNull(x)) {
-            return serializerContext.serializedNullValue;
-        }
-        if (isDataView(x)) {
-            const arrayBufferView = new Uint16Array(x.buffer);
-            const charCodeArray = Array.from(arrayBufferView);
-            return charCodeArray.map(c => String.fromCharCode(c)).join('');
-        }
-        if (serializerContext.log.errorEnabled) {
-            serializerContext.log.error(`${serializerContext.jsonPath}: cannot serialize value as data view.`, x);
-        }
-        return undefined;
-    }
-    deserialize(x, serializerContext) {
-        if (isUndefined(x)) {
-            return serializerContext.deserializedDefaultValue;
-        }
-        if (isNull(x)) {
-            return serializerContext.deserializedNullValue;
-        }
-        if (isString(x)) {
-            const arrayBuffer = new ArrayBuffer(x.length * 2);
-            const arrayBufferView = new Uint16Array(arrayBuffer);
-            for (let i = 0; i < x.length; i++) {
-                arrayBufferView[i] = x.charCodeAt(i);
-            }
-            return new DataView(arrayBuffer);
-        }
-        if (serializerContext.log.errorEnabled) {
-            serializerContext.log.error(`${serializerContext.jsonPath}: cannot deserialize value as data view.`, x);
-        }
-        return undefined;
-    }
-}
+import { isNull, isString, isUndefined } from 'lodash';
+import { isDataView } from '../functions/is-data-view';
+export class DataViewSerializer {
+    serialize(x, serializerContext) {
+        if (isUndefined(x)) {
+            return serializerContext.serializedDefaultValue;
+        }
+        if (isNull(x)) {
+            return serializerContext.serializedNullValue;
+        }
+        if (isDataView(x)) {
+            const arrayBufferView = new Uint16Array(x.buffer);
+            const charCodeArray = Array.from(arrayBufferView);
+            return charCodeArray.map(c => String.fromCharCode(c)).join('');
+        }
+        if (serializerContext.log.errorEnabled) {
+            serializerContext.log.error(`${serializerContext.jsonPath}: cannot serialize value as data view.`, x);
+        }
+        return undefined;
+    }
+    deserialize(x, serializerContext) {
+        if (isUndefined(x)) {
+            return serializerContext.deserializedDefaultValue;
+        }
+        if (isNull(x)) {
+            return serializerContext.deserializedNullValue;
+        }
+        if (isString(x)) {
+            const arrayBuffer = new ArrayBuffer(x.length * 2);
+            const arrayBufferView = new Uint16Array(arrayBuffer);
+            for (let i = 0; i < x.length; i++) {
+                arrayBufferView[i] = x.charCodeAt(i);
+            }
+            return new DataView(arrayBuffer);
+        }
+        if (serializerContext.log.errorEnabled) {
+            serializerContext.log.error(`${serializerContext.jsonPath}: cannot deserialize value as data view.`, x);
+        }
+        return undefined;
+    }
+}
 //# sourceMappingURL=data-view-serializer.js.map

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

@@ -1,34 +1,34 @@
-import { isDate, isNull, isString, isUndefined } from 'lodash';
-export class DateSerializer {
-    serialize(x, serializerContext) {
-        if (isUndefined(x)) {
-            return serializerContext.serializedDefaultValue;
-        }
-        if (isNull(x)) {
-            return serializerContext.serializedNullValue;
-        }
-        if (isDate(x)) {
-            return x.toISOString();
-        }
-        if (serializerContext.log.errorEnabled) {
-            serializerContext.log.error(`${serializerContext.jsonPath}: cannot serialize value as date.`, x);
-        }
-        return undefined;
-    }
-    deserialize(x, serializerContext) {
-        if (isUndefined(x)) {
-            return serializerContext.deserializedDefaultValue;
-        }
-        if (isNull(x)) {
-            return serializerContext.deserializedNullValue;
-        }
-        if (isString(x)) {
-            return new Date(x);
-        }
-        if (serializerContext.log.errorEnabled) {
-            serializerContext.log.error(`${serializerContext.jsonPath}: cannot deserialize value as date.`, x);
-        }
-        return undefined;
-    }
-}
+import { isDate, isNull, isString, isUndefined } from 'lodash';
+export class DateSerializer {
+    serialize(x, serializerContext) {
+        if (isUndefined(x)) {
+            return serializerContext.serializedDefaultValue;
+        }
+        if (isNull(x)) {
+            return serializerContext.serializedNullValue;
+        }
+        if (isDate(x)) {
+            return x.toISOString();
+        }
+        if (serializerContext.log.errorEnabled) {
+            serializerContext.log.error(`${serializerContext.jsonPath}: cannot serialize value as date.`, x);
+        }
+        return undefined;
+    }
+    deserialize(x, serializerContext) {
+        if (isUndefined(x)) {
+            return serializerContext.deserializedDefaultValue;
+        }
+        if (isNull(x)) {
+            return serializerContext.deserializedNullValue;
+        }
+        if (isString(x)) {
+            return new Date(x);
+        }
+        if (serializerContext.log.errorEnabled) {
+            serializerContext.log.error(`${serializerContext.jsonPath}: cannot deserialize value as date.`, x);
+        }
+        return undefined;
+    }
+}
 //# sourceMappingURL=date-serializer.js.map

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

@@ -1,35 +1,35 @@
-import { isArray, isNull, isUndefined } from 'lodash';
-import { isFloat32Array } from '../functions/is-float-32-array';
-export class Float32ArraySerializer {
-    serialize(x, serializerContext) {
-        if (isUndefined(x)) {
-            return serializerContext.serializedDefaultValue;
-        }
-        if (isNull(x)) {
-            return serializerContext.serializedNullValue;
-        }
-        if (isFloat32Array(x)) {
-            return Array.from(x);
-        }
-        if (serializerContext.log.errorEnabled) {
-            serializerContext.log.error(`${serializerContext.jsonPath}: cannot serialize value as float 32 array.`, x);
-        }
-        return undefined;
-    }
-    deserialize(x, serializerContext) {
-        if (isUndefined(x)) {
-            return serializerContext.deserializedDefaultValue;
-        }
-        if (isNull(x)) {
-            return serializerContext.deserializedNullValue;
-        }
-        if (isArray(x)) {
-            return Float32Array.from(x);
-        }
-        if (serializerContext.log.errorEnabled) {
-            serializerContext.log.error(`${serializerContext.jsonPath}: cannot deserialize value as float 32 array.`, x);
-        }
-        return undefined;
-    }
-}
+import { isArray, isNull, isUndefined } from 'lodash';
+import { isFloat32Array } from '../functions/is-float-32-array';
+export class Float32ArraySerializer {
+    serialize(x, serializerContext) {
+        if (isUndefined(x)) {
+            return serializerContext.serializedDefaultValue;
+        }
+        if (isNull(x)) {
+            return serializerContext.serializedNullValue;
+        }
+        if (isFloat32Array(x)) {
+            return Array.from(x);
+        }
+        if (serializerContext.log.errorEnabled) {
+            serializerContext.log.error(`${serializerContext.jsonPath}: cannot serialize value as float 32 array.`, x);
+        }
+        return undefined;
+    }
+    deserialize(x, serializerContext) {
+        if (isUndefined(x)) {
+            return serializerContext.deserializedDefaultValue;
+        }
+        if (isNull(x)) {
+            return serializerContext.deserializedNullValue;
+        }
+        if (isArray(x)) {
+            return Float32Array.from(x);
+        }
+        if (serializerContext.log.errorEnabled) {
+            serializerContext.log.error(`${serializerContext.jsonPath}: cannot deserialize value as float 32 array.`, x);
+        }
+        return undefined;
+    }
+}
 //# sourceMappingURL=float-32-array-serializer.js.map

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