decoders 1.26.0-test1 → 2.0.0-beta1
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/CHANGELOG.md +23 -3
- package/cjs/_guard.js +26 -0
- package/cjs/_guard.js.flow +20 -0
- package/cjs/_types.js +1 -0
- package/cjs/_types.js.flow +20 -0
- package/cjs/_utils.js +108 -0
- package/cjs/_utils.js.flow +97 -0
- package/cjs/annotate.js +161 -0
- package/cjs/annotate.js.flow +218 -0
- package/cjs/format/index.js +12 -0
- package/cjs/format/index.js.flow +4 -0
- package/cjs/format/inline.js +146 -0
- package/cjs/format/inline.js.flow +122 -0
- package/cjs/format/short.js +10 -0
- package/cjs/format/short.js.flow +8 -0
- package/cjs/index.js +118 -395
- package/cjs/index.js.flow +31 -24
- package/cjs/result.js +172 -0
- package/cjs/result.js.flow +166 -0
- package/cjs/stdlib/array.js +108 -0
- package/cjs/{array.js.flow → stdlib/array.js.flow} +22 -25
- package/cjs/stdlib/boolean.js +44 -0
- package/cjs/{boolean.js.flow → stdlib/boolean.js.flow} +8 -7
- package/cjs/stdlib/composition.js +56 -0
- package/cjs/{utils.js.flow → stdlib/composition.js.flow} +7 -22
- package/cjs/stdlib/constants.js +69 -0
- package/cjs/{constants.js.flow → stdlib/constants.js.flow} +13 -12
- package/cjs/stdlib/date.js +46 -0
- package/cjs/{date.js.flow → stdlib/date.js.flow} +9 -7
- package/cjs/stdlib/describe.js +26 -0
- package/cjs/{describe.js.flow → stdlib/describe.js.flow} +4 -4
- package/cjs/stdlib/dispatch.js +62 -0
- package/cjs/{dispatch.js.flow → stdlib/dispatch.js.flow} +6 -5
- package/cjs/stdlib/either.js +117 -0
- package/cjs/{either.js.flow → stdlib/either.js.flow} +55 -35
- package/cjs/stdlib/fail.js +21 -0
- package/cjs/stdlib/fail.js.flow +12 -0
- package/cjs/stdlib/instanceOf.js +19 -0
- package/cjs/{instanceOf.js.flow → stdlib/instanceOf.js.flow} +7 -8
- package/cjs/{json.js → stdlib/json.js} +3 -5
- package/cjs/{json.js.flow → stdlib/json.js.flow} +4 -4
- package/cjs/{lazy.js → stdlib/lazy.js} +1 -3
- package/cjs/{lazy.js.flow → stdlib/lazy.js.flow} +1 -1
- package/cjs/stdlib/mapping.js +67 -0
- package/cjs/stdlib/mapping.js.flow +54 -0
- package/cjs/stdlib/number.js +40 -0
- package/cjs/{number.js.flow → stdlib/number.js.flow} +10 -11
- package/cjs/stdlib/object.js +194 -0
- package/cjs/{object.js.flow → stdlib/object.js.flow} +44 -52
- package/cjs/stdlib/optional.js +54 -0
- package/cjs/{optional.js.flow → stdlib/optional.js.flow} +6 -7
- package/cjs/stdlib/string.js +98 -0
- package/cjs/{string.js.flow → stdlib/string.js.flow} +13 -12
- package/cjs/stdlib/tuple.js +173 -0
- package/cjs/{tuple.js.flow → stdlib/tuple.js.flow} +62 -63
- package/es/_guard.js +15 -0
- package/es/_types.js +0 -0
- package/es/_utils.js +93 -0
- package/es/annotate.js +144 -0
- package/es/format/index.js +2 -0
- package/es/format/inline.js +137 -0
- package/es/format/short.js +4 -0
- package/es/index.js +36 -1211
- package/es/result.js +139 -0
- package/es/stdlib/array.js +91 -0
- package/es/stdlib/boolean.js +28 -0
- package/es/stdlib/composition.js +42 -0
- package/es/stdlib/constants.js +46 -0
- package/es/stdlib/date.js +28 -0
- package/{cjs → es/stdlib}/describe.js +5 -11
- package/{cjs → es/stdlib}/dispatch.js +8 -15
- package/es/stdlib/either.js +90 -0
- package/es/stdlib/fail.js +11 -0
- package/es/stdlib/instanceOf.js +8 -0
- package/es/stdlib/json.js +15 -0
- package/es/stdlib/lazy.js +11 -0
- package/es/stdlib/mapping.js +54 -0
- package/es/stdlib/number.js +25 -0
- package/es/stdlib/object.js +175 -0
- package/es/stdlib/optional.js +38 -0
- package/{cjs → es/stdlib}/string.js +18 -35
- package/es/stdlib/tuple.js +155 -0
- package/package.json +9 -5
- package/ts/_guard.d.ts +7 -0
- package/ts/{helpers.d.ts → _helpers.d.ts} +0 -0
- package/ts/{types.d.ts → _types.d.ts} +3 -5
- package/ts/{utils.d.ts → _utils.d.ts} +3 -3
- package/ts/annotate.d.ts +58 -0
- package/ts/array.d.ts +1 -1
- package/ts/boolean.d.ts +1 -1
- package/ts/constants.d.ts +1 -1
- package/ts/date.d.ts +1 -1
- package/ts/describe.d.ts +1 -1
- package/ts/dispatch.d.ts +3 -3
- package/ts/either.d.ts +8 -8
- package/ts/fail.d.ts +1 -1
- package/ts/index.d.ts +30 -26
- package/ts/inline.d.ts +3 -0
- package/ts/instanceOf.d.ts +1 -1
- package/ts/json.d.ts +1 -1
- package/ts/lazy.d.ts +1 -1
- package/ts/mapping.d.ts +1 -1
- package/ts/number.d.ts +1 -1
- package/ts/object.d.ts +6 -6
- package/ts/optional.d.ts +1 -1
- package/ts/result.d.ts +39 -0
- package/ts/short.d.ts +3 -0
- package/ts/string.d.ts +1 -1
- package/ts/tuple.d.ts +5 -5
- package/cjs/array.js +0 -133
- package/cjs/boolean.js +0 -42
- package/cjs/constants.js +0 -67
- package/cjs/date.js +0 -42
- package/cjs/either.js +0 -85
- package/cjs/fail.js +0 -19
- package/cjs/fail.js.flow +0 -13
- package/cjs/guard.js +0 -30
- package/cjs/guard.js.flow +0 -36
- package/cjs/instanceOf.js +0 -17
- package/cjs/mapping.js +0 -113
- package/cjs/mapping.js.flow +0 -71
- package/cjs/number.js +0 -38
- package/cjs/object.js +0 -254
- package/cjs/optional.js +0 -52
- package/cjs/tuple.js +0 -199
- package/cjs/types.js +0 -5
- package/cjs/types.js.flow +0 -26
- package/cjs/utils.js +0 -70
- package/ts/guard.d.ts +0 -7
|
@@ -1,45 +1,65 @@
|
|
|
1
1
|
// @flow strict
|
|
2
2
|
|
|
3
|
-
import
|
|
4
|
-
import {
|
|
5
|
-
import {
|
|
6
|
-
|
|
7
|
-
import type { Decoder, Scalar } from './types';
|
|
3
|
+
import * as Result from '../result';
|
|
4
|
+
import { annotate } from '../annotate';
|
|
5
|
+
import { indent, summarize } from '../_utils';
|
|
6
|
+
import type { Decoder, Scalar } from '../_types';
|
|
8
7
|
|
|
9
8
|
/**
|
|
10
9
|
* Indents and adds a dash in front of this (potentially multiline) string.
|
|
11
10
|
*/
|
|
12
|
-
|
|
13
|
-
function itemize(s: string = ''): string {
|
|
11
|
+
function itemize(s: string): string {
|
|
14
12
|
return '-' + indent(s).substring(1);
|
|
15
13
|
}
|
|
16
14
|
|
|
15
|
+
/**
|
|
16
|
+
* Nests another error as an item under a new-to-be-created "Either error". If
|
|
17
|
+
* the given subitem already is an "Either error" of itself, don't indent, but
|
|
18
|
+
* just "inject" its items at the same error level, for nicely flattened either
|
|
19
|
+
* expressions.
|
|
20
|
+
*
|
|
21
|
+
* Avoids:
|
|
22
|
+
*
|
|
23
|
+
* Either:
|
|
24
|
+
* - Either:
|
|
25
|
+
* - Must be P
|
|
26
|
+
* - Either:
|
|
27
|
+
* - Must be Q
|
|
28
|
+
* - Must be R
|
|
29
|
+
* - Must be S
|
|
30
|
+
*
|
|
31
|
+
* And "flattens" these to:
|
|
32
|
+
*
|
|
33
|
+
* Either:
|
|
34
|
+
* - Must be P
|
|
35
|
+
* - Must be Q
|
|
36
|
+
* - Must be R
|
|
37
|
+
* - Must be S
|
|
38
|
+
*
|
|
39
|
+
*/
|
|
40
|
+
function nest(errText: string): string {
|
|
41
|
+
const EITHER_PREFIX = 'Either:\n';
|
|
42
|
+
return errText.startsWith(EITHER_PREFIX)
|
|
43
|
+
? errText.substr(EITHER_PREFIX.length)
|
|
44
|
+
: itemize(errText);
|
|
45
|
+
}
|
|
46
|
+
|
|
17
47
|
export function either<T1, T2>(d1: Decoder<T1>, d2: Decoder<T2>): Decoder<T1 | T2> {
|
|
18
48
|
return (blob: mixed) =>
|
|
19
|
-
d1(blob)
|
|
20
|
-
(
|
|
21
|
-
|
|
22
|
-
|
|
23
|
-
|
|
24
|
-
|
|
25
|
-
|
|
26
|
-
annotate(
|
|
27
|
-
blob,
|
|
28
|
-
[
|
|
29
|
-
'Either:',
|
|
30
|
-
itemize(summarize(err1).join('\n')),
|
|
31
|
-
itemize(summarize(err2).join('\n')),
|
|
32
|
-
].join('\n')
|
|
33
|
-
)
|
|
34
|
-
)
|
|
35
|
-
)
|
|
49
|
+
Result.orElse(d1(blob), (err1) =>
|
|
50
|
+
Result.orElse(d2(blob), (err2) => {
|
|
51
|
+
const serr1 = summarize(err1).join('\n');
|
|
52
|
+
const serr2 = summarize(err2).join('\n');
|
|
53
|
+
const text = ['Either:', nest(serr1), nest(serr2)].join('\n');
|
|
54
|
+
return Result.err(annotate(blob, text));
|
|
55
|
+
}),
|
|
36
56
|
);
|
|
37
57
|
}
|
|
38
58
|
|
|
39
59
|
export function either3<T1, T2, T3>(
|
|
40
60
|
d1: Decoder<T1>,
|
|
41
61
|
d2: Decoder<T2>,
|
|
42
|
-
d3: Decoder<T3
|
|
62
|
+
d3: Decoder<T3>,
|
|
43
63
|
): Decoder<T1 | T2 | T3> {
|
|
44
64
|
return either(d1, either(d2, d3));
|
|
45
65
|
}
|
|
@@ -48,7 +68,7 @@ export function either4<T1, T2, T3, T4>(
|
|
|
48
68
|
d1: Decoder<T1>,
|
|
49
69
|
d2: Decoder<T2>,
|
|
50
70
|
d3: Decoder<T3>,
|
|
51
|
-
d4: Decoder<T4
|
|
71
|
+
d4: Decoder<T4>,
|
|
52
72
|
): Decoder<T1 | T2 | T3 | T4> {
|
|
53
73
|
return either(d1, either3(d2, d3, d4));
|
|
54
74
|
}
|
|
@@ -58,7 +78,7 @@ export function either5<T1, T2, T3, T4, T5>(
|
|
|
58
78
|
d2: Decoder<T2>,
|
|
59
79
|
d3: Decoder<T3>,
|
|
60
80
|
d4: Decoder<T4>,
|
|
61
|
-
d5: Decoder<T5
|
|
81
|
+
d5: Decoder<T5>,
|
|
62
82
|
): Decoder<T1 | T2 | T3 | T4 | T5> {
|
|
63
83
|
return either(d1, either4(d2, d3, d4, d5));
|
|
64
84
|
}
|
|
@@ -69,7 +89,7 @@ export function either6<T1, T2, T3, T4, T5, T6>(
|
|
|
69
89
|
d3: Decoder<T3>,
|
|
70
90
|
d4: Decoder<T4>,
|
|
71
91
|
d5: Decoder<T5>,
|
|
72
|
-
d6: Decoder<T6
|
|
92
|
+
d6: Decoder<T6>,
|
|
73
93
|
): Decoder<T1 | T2 | T3 | T4 | T5 | T6> {
|
|
74
94
|
return either(d1, either5(d2, d3, d4, d5, d6));
|
|
75
95
|
}
|
|
@@ -81,7 +101,7 @@ export function either7<T1, T2, T3, T4, T5, T6, T7>(
|
|
|
81
101
|
d4: Decoder<T4>,
|
|
82
102
|
d5: Decoder<T5>,
|
|
83
103
|
d6: Decoder<T6>,
|
|
84
|
-
d7: Decoder<T7
|
|
104
|
+
d7: Decoder<T7>,
|
|
85
105
|
): Decoder<T1 | T2 | T3 | T4 | T5 | T6 | T7> {
|
|
86
106
|
return either(d1, either6(d2, d3, d4, d5, d6, d7));
|
|
87
107
|
}
|
|
@@ -94,7 +114,7 @@ export function either8<T1, T2, T3, T4, T5, T6, T7, T8>(
|
|
|
94
114
|
d5: Decoder<T5>,
|
|
95
115
|
d6: Decoder<T6>,
|
|
96
116
|
d7: Decoder<T7>,
|
|
97
|
-
d8: Decoder<T8
|
|
117
|
+
d8: Decoder<T8>,
|
|
98
118
|
): Decoder<T1 | T2 | T3 | T4 | T5 | T6 | T7 | T8> {
|
|
99
119
|
return either(d1, either7(d2, d3, d4, d5, d6, d7, d8));
|
|
100
120
|
}
|
|
@@ -108,7 +128,7 @@ export function either9<T1, T2, T3, T4, T5, T6, T7, T8, T9>(
|
|
|
108
128
|
d6: Decoder<T6>,
|
|
109
129
|
d7: Decoder<T7>,
|
|
110
130
|
d8: Decoder<T8>,
|
|
111
|
-
d9: Decoder<T9
|
|
131
|
+
d9: Decoder<T9>,
|
|
112
132
|
): Decoder<T1 | T2 | T3 | T4 | T5 | T6 | T7 | T8 | T9> {
|
|
113
133
|
return either(d1, either8(d2, d3, d4, d5, d6, d7, d8, d9));
|
|
114
134
|
}
|
|
@@ -117,15 +137,15 @@ export function oneOf<T: Scalar>(constants: $ReadOnlyArray<T>): Decoder<T> {
|
|
|
117
137
|
return (blob: mixed) => {
|
|
118
138
|
const winner = constants.find((c) => c === blob);
|
|
119
139
|
if (winner !== undefined) {
|
|
120
|
-
return
|
|
140
|
+
return Result.ok(winner);
|
|
121
141
|
}
|
|
122
|
-
return
|
|
142
|
+
return Result.err(
|
|
123
143
|
annotate(
|
|
124
144
|
blob,
|
|
125
145
|
`Must be one of ${constants
|
|
126
146
|
.map((value) => JSON.stringify(value))
|
|
127
|
-
.join(', ')}
|
|
128
|
-
)
|
|
147
|
+
.join(', ')}`,
|
|
148
|
+
),
|
|
129
149
|
);
|
|
130
150
|
};
|
|
131
151
|
}
|
|
@@ -0,0 +1,21 @@
|
|
|
1
|
+
"use strict";
|
|
2
|
+
|
|
3
|
+
exports.__esModule = true;
|
|
4
|
+
exports.fail = fail;
|
|
5
|
+
|
|
6
|
+
var Result = _interopRequireWildcard(require("../result"));
|
|
7
|
+
|
|
8
|
+
var _annotate = require("../annotate");
|
|
9
|
+
|
|
10
|
+
function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
|
|
11
|
+
|
|
12
|
+
function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
|
|
13
|
+
|
|
14
|
+
/**
|
|
15
|
+
* Decoder that always fails with the given error message, no matter what the input.
|
|
16
|
+
*/
|
|
17
|
+
function fail(msg) {
|
|
18
|
+
return function (blob) {
|
|
19
|
+
return Result.err((0, _annotate.annotate)(blob, msg));
|
|
20
|
+
};
|
|
21
|
+
}
|
|
@@ -0,0 +1,12 @@
|
|
|
1
|
+
// @flow strict
|
|
2
|
+
|
|
3
|
+
import * as Result from '../result';
|
|
4
|
+
import { annotate } from '../annotate';
|
|
5
|
+
import type { Decoder } from '../_types';
|
|
6
|
+
|
|
7
|
+
/**
|
|
8
|
+
* Decoder that always fails with the given error message, no matter what the input.
|
|
9
|
+
*/
|
|
10
|
+
export function fail(msg: string): Decoder<empty> {
|
|
11
|
+
return (blob: mixed) => Result.err(annotate(blob, msg));
|
|
12
|
+
}
|
|
@@ -0,0 +1,19 @@
|
|
|
1
|
+
"use strict";
|
|
2
|
+
|
|
3
|
+
exports.__esModule = true;
|
|
4
|
+
exports.instanceOf = instanceOf;
|
|
5
|
+
|
|
6
|
+
var Result = _interopRequireWildcard(require("../result"));
|
|
7
|
+
|
|
8
|
+
var _annotate = require("../annotate");
|
|
9
|
+
|
|
10
|
+
function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
|
|
11
|
+
|
|
12
|
+
function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
|
|
13
|
+
|
|
14
|
+
function instanceOf(klass) {
|
|
15
|
+
return function (blob) {
|
|
16
|
+
return blob instanceof klass ? Result.ok(blob) : Result.err((0, _annotate.annotate)(blob, "Must be " + // $FlowFixMe[incompatible-use] - klass.name is fine?
|
|
17
|
+
klass.name + " instance"));
|
|
18
|
+
};
|
|
19
|
+
}
|
|
@@ -1,21 +1,20 @@
|
|
|
1
1
|
// @flow strict
|
|
2
2
|
|
|
3
|
-
import
|
|
4
|
-
import {
|
|
5
|
-
|
|
6
|
-
import type { Decoder } from './types';
|
|
3
|
+
import * as Result from '../result';
|
|
4
|
+
import { annotate } from '../annotate';
|
|
5
|
+
import type { Decoder } from '../_types';
|
|
7
6
|
|
|
8
7
|
export function instanceOf<T>(klass: Class<T>): Decoder<T> {
|
|
9
8
|
return (blob: mixed) =>
|
|
10
9
|
blob instanceof klass
|
|
11
|
-
?
|
|
12
|
-
:
|
|
10
|
+
? Result.ok(blob)
|
|
11
|
+
: Result.err(
|
|
13
12
|
annotate(
|
|
14
13
|
blob,
|
|
15
14
|
`Must be ${
|
|
16
15
|
// $FlowFixMe[incompatible-use] - klass.name is fine?
|
|
17
16
|
klass.name
|
|
18
|
-
} instance
|
|
19
|
-
)
|
|
17
|
+
} instance`,
|
|
18
|
+
),
|
|
20
19
|
);
|
|
21
20
|
}
|
|
@@ -1,21 +1,19 @@
|
|
|
1
1
|
"use strict";
|
|
2
2
|
|
|
3
|
-
|
|
4
|
-
value: true
|
|
5
|
-
});
|
|
3
|
+
exports.__esModule = true;
|
|
6
4
|
exports.jsonObject = exports.jsonArray = exports.json = void 0;
|
|
7
5
|
|
|
8
6
|
var _array = require("./array");
|
|
9
7
|
|
|
10
8
|
var _boolean2 = require("./boolean");
|
|
11
9
|
|
|
12
|
-
var
|
|
10
|
+
var _mapping = require("./mapping");
|
|
13
11
|
|
|
14
12
|
var _either = require("./either");
|
|
15
13
|
|
|
16
14
|
var _lazy = require("./lazy");
|
|
17
15
|
|
|
18
|
-
var
|
|
16
|
+
var _constants = require("./constants");
|
|
19
17
|
|
|
20
18
|
var _number = require("./number");
|
|
21
19
|
|
|
@@ -2,13 +2,13 @@
|
|
|
2
2
|
|
|
3
3
|
import { array } from './array';
|
|
4
4
|
import { boolean } from './boolean';
|
|
5
|
-
import {
|
|
5
|
+
import { dict } from './mapping';
|
|
6
6
|
import { either6 } from './either';
|
|
7
7
|
import { lazy } from './lazy';
|
|
8
|
-
import {
|
|
8
|
+
import { null_ } from './constants';
|
|
9
9
|
import { number } from './number';
|
|
10
10
|
import { string } from './string';
|
|
11
|
-
import type { Decoder } from '
|
|
11
|
+
import type { Decoder } from '../_types';
|
|
12
12
|
|
|
13
13
|
export type JSONValue = null | string | number | boolean | JSONObject | JSONArray;
|
|
14
14
|
export type JSONObject = { [string]: JSONValue };
|
|
@@ -24,5 +24,5 @@ export const json: Decoder<JSONValue> = either6(
|
|
|
24
24
|
number,
|
|
25
25
|
boolean,
|
|
26
26
|
jsonObject,
|
|
27
|
-
jsonArray
|
|
27
|
+
jsonArray,
|
|
28
28
|
);
|
|
@@ -0,0 +1,67 @@
|
|
|
1
|
+
"use strict";
|
|
2
|
+
|
|
3
|
+
exports.__esModule = true;
|
|
4
|
+
exports.dict = dict;
|
|
5
|
+
exports.mapping = mapping;
|
|
6
|
+
|
|
7
|
+
var Result = _interopRequireWildcard(require("../result"));
|
|
8
|
+
|
|
9
|
+
var _annotate = require("../annotate");
|
|
10
|
+
|
|
11
|
+
var _composition = require("./composition");
|
|
12
|
+
|
|
13
|
+
var _object = require("./object");
|
|
14
|
+
|
|
15
|
+
function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
|
|
16
|
+
|
|
17
|
+
function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
|
|
18
|
+
|
|
19
|
+
/**
|
|
20
|
+
* Given an object, will decode a Map of string keys to whatever values.
|
|
21
|
+
*
|
|
22
|
+
* For example, given a decoder for a Person, we can verify a Person lookup
|
|
23
|
+
* table structure (of type Map<string, Person>) like so:
|
|
24
|
+
*
|
|
25
|
+
* mapping(person)
|
|
26
|
+
*
|
|
27
|
+
*/
|
|
28
|
+
function mapping(decoder) {
|
|
29
|
+
return (0, _composition.compose)(_object.pojo, function (blob) {
|
|
30
|
+
var tuples = [];
|
|
31
|
+
var errors = null;
|
|
32
|
+
Object.keys(blob).forEach(function (key) {
|
|
33
|
+
var value = blob[key];
|
|
34
|
+
var result = decoder(value);
|
|
35
|
+
|
|
36
|
+
if (result.type === 'ok') {
|
|
37
|
+
if (errors === null) {
|
|
38
|
+
tuples.push([key, result.value]);
|
|
39
|
+
}
|
|
40
|
+
} else {
|
|
41
|
+
tuples.length = 0; // Clear the tuples array
|
|
42
|
+
|
|
43
|
+
if (errors === null) {
|
|
44
|
+
errors = {};
|
|
45
|
+
}
|
|
46
|
+
|
|
47
|
+
errors[key] = result.error;
|
|
48
|
+
}
|
|
49
|
+
});
|
|
50
|
+
|
|
51
|
+
if (errors !== null) {
|
|
52
|
+
return Result.err((0, _annotate.merge)((0, _annotate.annotateObject)(blob), errors));
|
|
53
|
+
} else {
|
|
54
|
+
return Result.ok(new Map(tuples));
|
|
55
|
+
}
|
|
56
|
+
});
|
|
57
|
+
}
|
|
58
|
+
/**
|
|
59
|
+
* Like mapping(), but returns an object rather than a Map instance.
|
|
60
|
+
*/
|
|
61
|
+
|
|
62
|
+
|
|
63
|
+
function dict(decoder) {
|
|
64
|
+
return (0, _composition.map)(mapping(decoder), function (m) {
|
|
65
|
+
return Object.fromEntries(m);
|
|
66
|
+
});
|
|
67
|
+
}
|
|
@@ -0,0 +1,54 @@
|
|
|
1
|
+
// @flow strict
|
|
2
|
+
|
|
3
|
+
import * as Result from '../result';
|
|
4
|
+
import { annotateObject } from '../annotate';
|
|
5
|
+
import { compose, map } from './composition';
|
|
6
|
+
import { merge } from '../annotate';
|
|
7
|
+
import { pojo } from './object';
|
|
8
|
+
import type { Annotation } from '../annotate';
|
|
9
|
+
import type { Decoder } from '../_types';
|
|
10
|
+
|
|
11
|
+
/**
|
|
12
|
+
* Given an object, will decode a Map of string keys to whatever values.
|
|
13
|
+
*
|
|
14
|
+
* For example, given a decoder for a Person, we can verify a Person lookup
|
|
15
|
+
* table structure (of type Map<string, Person>) like so:
|
|
16
|
+
*
|
|
17
|
+
* mapping(person)
|
|
18
|
+
*
|
|
19
|
+
*/
|
|
20
|
+
export function mapping<T>(decoder: Decoder<T>): Decoder<Map<string, T>> {
|
|
21
|
+
return compose(pojo, (blob: { +[key: string]: mixed }) => {
|
|
22
|
+
let tuples: Array<[string, T]> = [];
|
|
23
|
+
let errors: { [key: string]: Annotation } | null = null;
|
|
24
|
+
|
|
25
|
+
Object.keys(blob).forEach((key: string) => {
|
|
26
|
+
const value = blob[key];
|
|
27
|
+
const result = decoder(value);
|
|
28
|
+
if (result.type === 'ok') {
|
|
29
|
+
if (errors === null) {
|
|
30
|
+
tuples.push([key, result.value]);
|
|
31
|
+
}
|
|
32
|
+
} else {
|
|
33
|
+
tuples.length = 0; // Clear the tuples array
|
|
34
|
+
if (errors === null) {
|
|
35
|
+
errors = {};
|
|
36
|
+
}
|
|
37
|
+
errors[key] = result.error;
|
|
38
|
+
}
|
|
39
|
+
});
|
|
40
|
+
|
|
41
|
+
if (errors !== null) {
|
|
42
|
+
return Result.err(merge(annotateObject(blob), errors));
|
|
43
|
+
} else {
|
|
44
|
+
return Result.ok(new Map(tuples));
|
|
45
|
+
}
|
|
46
|
+
});
|
|
47
|
+
}
|
|
48
|
+
|
|
49
|
+
/**
|
|
50
|
+
* Like mapping(), but returns an object rather than a Map instance.
|
|
51
|
+
*/
|
|
52
|
+
export function dict<T>(decoder: Decoder<T>): Decoder<{ [string]: T }> {
|
|
53
|
+
return map(mapping(decoder), (m) => Object.fromEntries(m));
|
|
54
|
+
}
|
|
@@ -0,0 +1,40 @@
|
|
|
1
|
+
"use strict";
|
|
2
|
+
|
|
3
|
+
exports.__esModule = true;
|
|
4
|
+
exports.positiveNumber = exports.positiveInteger = exports.number = exports.integer = void 0;
|
|
5
|
+
|
|
6
|
+
var Result = _interopRequireWildcard(require("../result"));
|
|
7
|
+
|
|
8
|
+
var _annotate = require("../annotate");
|
|
9
|
+
|
|
10
|
+
var _composition = require("./composition");
|
|
11
|
+
|
|
12
|
+
function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
|
|
13
|
+
|
|
14
|
+
function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
|
|
15
|
+
|
|
16
|
+
var anyNumber = function anyNumber(blob) {
|
|
17
|
+
return typeof blob === 'number' && !Number.isNaN(blob) ? Result.ok(blob) : Result.err((0, _annotate.annotate)(blob, 'Must be number'));
|
|
18
|
+
};
|
|
19
|
+
|
|
20
|
+
var isInteger = function isInteger(n) {
|
|
21
|
+
return Number.isInteger(n);
|
|
22
|
+
};
|
|
23
|
+
|
|
24
|
+
var isFinite = function isFinite(n) {
|
|
25
|
+
return Number.isFinite(n);
|
|
26
|
+
};
|
|
27
|
+
|
|
28
|
+
var number = (0, _composition.compose)(anyNumber, (0, _composition.predicate)(isFinite, 'Number must be finite'));
|
|
29
|
+
exports.number = number;
|
|
30
|
+
var positiveNumber = (0, _composition.compose)(number, (0, _composition.predicate)(function (n) {
|
|
31
|
+
return n >= 0;
|
|
32
|
+
}, 'Number must be positive')); // Integers
|
|
33
|
+
|
|
34
|
+
exports.positiveNumber = positiveNumber;
|
|
35
|
+
var integer = (0, _composition.compose)(number, (0, _composition.predicate)(isInteger, 'Number must be an integer'));
|
|
36
|
+
exports.integer = integer;
|
|
37
|
+
var positiveInteger = (0, _composition.compose)(integer, (0, _composition.predicate)(function (n) {
|
|
38
|
+
return n >= 0;
|
|
39
|
+
}, 'Number must be positive'));
|
|
40
|
+
exports.positiveInteger = positiveInteger;
|
|
@@ -1,15 +1,14 @@
|
|
|
1
1
|
// @flow strict
|
|
2
2
|
|
|
3
|
-
import
|
|
4
|
-
import {
|
|
5
|
-
|
|
6
|
-
import type { Decoder } from '
|
|
7
|
-
import { compose, predicate } from './utils';
|
|
3
|
+
import * as Result from '../result';
|
|
4
|
+
import { annotate } from '../annotate';
|
|
5
|
+
import { compose, predicate } from './composition';
|
|
6
|
+
import type { Decoder } from '../_types';
|
|
8
7
|
|
|
9
8
|
const anyNumber: Decoder<number> = (blob: mixed) => {
|
|
10
9
|
return typeof blob === 'number' && !Number.isNaN(blob)
|
|
11
|
-
?
|
|
12
|
-
:
|
|
10
|
+
? Result.ok(blob)
|
|
11
|
+
: Result.err(annotate(blob, 'Must be number'));
|
|
13
12
|
};
|
|
14
13
|
|
|
15
14
|
const isInteger = (n: number) => Number.isInteger(n);
|
|
@@ -17,19 +16,19 @@ const isFinite = (n: number) => Number.isFinite(n);
|
|
|
17
16
|
|
|
18
17
|
export const number: Decoder<number> = compose(
|
|
19
18
|
anyNumber,
|
|
20
|
-
predicate(isFinite, 'Number must be finite')
|
|
19
|
+
predicate(isFinite, 'Number must be finite'),
|
|
21
20
|
);
|
|
22
21
|
export const positiveNumber: Decoder<number> = compose(
|
|
23
22
|
number,
|
|
24
|
-
predicate((n) => n >= 0, 'Number must be positive')
|
|
23
|
+
predicate((n) => n >= 0, 'Number must be positive'),
|
|
25
24
|
);
|
|
26
25
|
|
|
27
26
|
// Integers
|
|
28
27
|
export const integer: Decoder<number> = compose(
|
|
29
28
|
number,
|
|
30
|
-
predicate(isInteger, 'Number must be an integer')
|
|
29
|
+
predicate(isInteger, 'Number must be an integer'),
|
|
31
30
|
);
|
|
32
31
|
export const positiveInteger: Decoder<number> = compose(
|
|
33
32
|
integer,
|
|
34
|
-
predicate((n) => n >= 0, 'Number must be positive')
|
|
33
|
+
predicate((n) => n >= 0, 'Number must be positive'),
|
|
35
34
|
);
|