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.
Files changed (129) hide show
  1. package/CHANGELOG.md +23 -3
  2. package/cjs/_guard.js +26 -0
  3. package/cjs/_guard.js.flow +20 -0
  4. package/cjs/_types.js +1 -0
  5. package/cjs/_types.js.flow +20 -0
  6. package/cjs/_utils.js +108 -0
  7. package/cjs/_utils.js.flow +97 -0
  8. package/cjs/annotate.js +161 -0
  9. package/cjs/annotate.js.flow +218 -0
  10. package/cjs/format/index.js +12 -0
  11. package/cjs/format/index.js.flow +4 -0
  12. package/cjs/format/inline.js +146 -0
  13. package/cjs/format/inline.js.flow +122 -0
  14. package/cjs/format/short.js +10 -0
  15. package/cjs/format/short.js.flow +8 -0
  16. package/cjs/index.js +118 -395
  17. package/cjs/index.js.flow +31 -24
  18. package/cjs/result.js +172 -0
  19. package/cjs/result.js.flow +166 -0
  20. package/cjs/stdlib/array.js +108 -0
  21. package/cjs/{array.js.flow → stdlib/array.js.flow} +22 -25
  22. package/cjs/stdlib/boolean.js +44 -0
  23. package/cjs/{boolean.js.flow → stdlib/boolean.js.flow} +8 -7
  24. package/cjs/stdlib/composition.js +56 -0
  25. package/cjs/{utils.js.flow → stdlib/composition.js.flow} +7 -22
  26. package/cjs/stdlib/constants.js +69 -0
  27. package/cjs/{constants.js.flow → stdlib/constants.js.flow} +13 -12
  28. package/cjs/stdlib/date.js +46 -0
  29. package/cjs/{date.js.flow → stdlib/date.js.flow} +9 -7
  30. package/cjs/stdlib/describe.js +26 -0
  31. package/cjs/{describe.js.flow → stdlib/describe.js.flow} +4 -4
  32. package/cjs/stdlib/dispatch.js +62 -0
  33. package/cjs/{dispatch.js.flow → stdlib/dispatch.js.flow} +6 -5
  34. package/cjs/stdlib/either.js +117 -0
  35. package/cjs/{either.js.flow → stdlib/either.js.flow} +55 -35
  36. package/cjs/stdlib/fail.js +21 -0
  37. package/cjs/stdlib/fail.js.flow +12 -0
  38. package/cjs/stdlib/instanceOf.js +19 -0
  39. package/cjs/{instanceOf.js.flow → stdlib/instanceOf.js.flow} +7 -8
  40. package/cjs/{json.js → stdlib/json.js} +3 -5
  41. package/cjs/{json.js.flow → stdlib/json.js.flow} +4 -4
  42. package/cjs/{lazy.js → stdlib/lazy.js} +1 -3
  43. package/cjs/{lazy.js.flow → stdlib/lazy.js.flow} +1 -1
  44. package/cjs/stdlib/mapping.js +67 -0
  45. package/cjs/stdlib/mapping.js.flow +54 -0
  46. package/cjs/stdlib/number.js +40 -0
  47. package/cjs/{number.js.flow → stdlib/number.js.flow} +10 -11
  48. package/cjs/stdlib/object.js +194 -0
  49. package/cjs/{object.js.flow → stdlib/object.js.flow} +44 -52
  50. package/cjs/stdlib/optional.js +54 -0
  51. package/cjs/{optional.js.flow → stdlib/optional.js.flow} +6 -7
  52. package/cjs/stdlib/string.js +98 -0
  53. package/cjs/{string.js.flow → stdlib/string.js.flow} +13 -12
  54. package/cjs/stdlib/tuple.js +173 -0
  55. package/cjs/{tuple.js.flow → stdlib/tuple.js.flow} +62 -63
  56. package/es/_guard.js +15 -0
  57. package/es/_types.js +0 -0
  58. package/es/_utils.js +93 -0
  59. package/es/annotate.js +144 -0
  60. package/es/format/index.js +2 -0
  61. package/es/format/inline.js +137 -0
  62. package/es/format/short.js +4 -0
  63. package/es/index.js +36 -1211
  64. package/es/result.js +139 -0
  65. package/es/stdlib/array.js +91 -0
  66. package/es/stdlib/boolean.js +28 -0
  67. package/es/stdlib/composition.js +42 -0
  68. package/es/stdlib/constants.js +46 -0
  69. package/es/stdlib/date.js +28 -0
  70. package/{cjs → es/stdlib}/describe.js +5 -11
  71. package/{cjs → es/stdlib}/dispatch.js +8 -15
  72. package/es/stdlib/either.js +90 -0
  73. package/es/stdlib/fail.js +11 -0
  74. package/es/stdlib/instanceOf.js +8 -0
  75. package/es/stdlib/json.js +15 -0
  76. package/es/stdlib/lazy.js +11 -0
  77. package/es/stdlib/mapping.js +54 -0
  78. package/es/stdlib/number.js +25 -0
  79. package/es/stdlib/object.js +175 -0
  80. package/es/stdlib/optional.js +38 -0
  81. package/{cjs → es/stdlib}/string.js +18 -35
  82. package/es/stdlib/tuple.js +155 -0
  83. package/package.json +9 -5
  84. package/ts/_guard.d.ts +7 -0
  85. package/ts/{helpers.d.ts → _helpers.d.ts} +0 -0
  86. package/ts/{types.d.ts → _types.d.ts} +3 -5
  87. package/ts/{utils.d.ts → _utils.d.ts} +3 -3
  88. package/ts/annotate.d.ts +58 -0
  89. package/ts/array.d.ts +1 -1
  90. package/ts/boolean.d.ts +1 -1
  91. package/ts/constants.d.ts +1 -1
  92. package/ts/date.d.ts +1 -1
  93. package/ts/describe.d.ts +1 -1
  94. package/ts/dispatch.d.ts +3 -3
  95. package/ts/either.d.ts +8 -8
  96. package/ts/fail.d.ts +1 -1
  97. package/ts/index.d.ts +30 -26
  98. package/ts/inline.d.ts +3 -0
  99. package/ts/instanceOf.d.ts +1 -1
  100. package/ts/json.d.ts +1 -1
  101. package/ts/lazy.d.ts +1 -1
  102. package/ts/mapping.d.ts +1 -1
  103. package/ts/number.d.ts +1 -1
  104. package/ts/object.d.ts +6 -6
  105. package/ts/optional.d.ts +1 -1
  106. package/ts/result.d.ts +39 -0
  107. package/ts/short.d.ts +3 -0
  108. package/ts/string.d.ts +1 -1
  109. package/ts/tuple.d.ts +5 -5
  110. package/cjs/array.js +0 -133
  111. package/cjs/boolean.js +0 -42
  112. package/cjs/constants.js +0 -67
  113. package/cjs/date.js +0 -42
  114. package/cjs/either.js +0 -85
  115. package/cjs/fail.js +0 -19
  116. package/cjs/fail.js.flow +0 -13
  117. package/cjs/guard.js +0 -30
  118. package/cjs/guard.js.flow +0 -36
  119. package/cjs/instanceOf.js +0 -17
  120. package/cjs/mapping.js +0 -113
  121. package/cjs/mapping.js.flow +0 -71
  122. package/cjs/number.js +0 -38
  123. package/cjs/object.js +0 -254
  124. package/cjs/optional.js +0 -52
  125. package/cjs/tuple.js +0 -199
  126. package/cjs/types.js +0 -5
  127. package/cjs/types.js.flow +0 -26
  128. package/cjs/utils.js +0 -70
  129. package/ts/guard.d.ts +0 -7
@@ -1,23 +1,8 @@
1
1
  // @flow strict
2
2
 
3
- import { annotate } from 'debrief';
4
- import { Err, Ok } from 'lemons/Result';
5
-
6
- import type { Decoder } from './types';
7
-
8
- /**
9
- * `x instanceof Date` checks are unreliable across stack frames (that information
10
- * might get lost by the JS runtime), so we'll have to reside to more runtime
11
- * inspection checks.
12
- *
13
- * Taken from https://stackoverflow.com/a/44198641
14
- */
15
- export const isDate = (value: mixed): boolean %checks =>
16
- value !== undefined &&
17
- value !== null &&
18
- // $FlowFixMe[method-unbinding]
19
- Object.prototype.toString.call(value) === '[object Date]' &&
20
- !isNaN(value);
3
+ import * as Result from '../result';
4
+ import { annotate } from '../annotate';
5
+ import type { Decoder } from '../_types';
21
6
 
22
7
  /**
23
8
  * Given a decoder T and a mapping function from T's to V's, returns a decoder
@@ -26,9 +11,9 @@ export const isDate = (value: mixed): boolean %checks =>
26
11
  export function map<T, V>(decoder: Decoder<T>, mapper: (T) => V): Decoder<V> {
27
12
  return compose(decoder, (x) => {
28
13
  try {
29
- return Ok(mapper(x));
14
+ return Result.ok(mapper(x));
30
15
  } catch (e) {
31
- return Err(annotate(x, e instanceof Error ? e.message : String(e)));
16
+ return Result.err(annotate(x, e instanceof Error ? e.message : String(e)));
32
17
  }
33
18
  });
34
19
  }
@@ -44,7 +29,7 @@ export function map<T, V>(decoder: Decoder<T>, mapper: (T) => V): Decoder<V> {
44
29
  * argument.
45
30
  */
46
31
  export function compose<T, V>(decoder: Decoder<T>, next: Decoder<V, T>): Decoder<V> {
47
- return (blob: mixed) => decoder(blob).andThen(next);
32
+ return (blob: mixed) => Result.andThen(decoder(blob), next);
48
33
  }
49
34
 
50
35
  /**
@@ -53,6 +38,6 @@ export function compose<T, V>(decoder: Decoder<T>, next: Decoder<V, T>): Decoder
53
38
  */
54
39
  export function predicate<T>(predicate: (T) => boolean, msg: string): Decoder<T, T> {
55
40
  return (value: T) => {
56
- return predicate(value) ? Ok(value) : Err(annotate(value, msg));
41
+ return predicate(value) ? Result.ok(value) : Result.err(annotate(value, msg));
57
42
  };
58
43
  }
@@ -0,0 +1,69 @@
1
+ "use strict";
2
+
3
+ exports.__esModule = true;
4
+ exports.constant = constant;
5
+ exports.hardcoded = hardcoded;
6
+ exports.unknown = exports.undefined_ = exports.null_ = exports.mixed = void 0;
7
+
8
+ var Result = _interopRequireWildcard(require("../result"));
9
+
10
+ var _annotate = require("../annotate");
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
+ /**
17
+ * Decoder that only returns Ok for `null` inputs. Err otherwise.
18
+ */
19
+ var null_ = function null_(blob) {
20
+ return blob === null ? Result.ok(blob) : Result.err((0, _annotate.annotate)(blob, 'Must be null'));
21
+ };
22
+ /**
23
+ * Decoder that only returns Ok for `undefined` inputs. Err otherwise.
24
+ */
25
+
26
+
27
+ exports.null_ = null_;
28
+
29
+ var undefined_ = function undefined_(blob) {
30
+ return blob === undefined ? Result.ok(blob) : Result.err((0, _annotate.annotate)(blob, 'Must be undefined'));
31
+ };
32
+ /**
33
+ * Decoder that only returns Ok for the given value constant. Err otherwise.
34
+ */
35
+
36
+
37
+ exports.undefined_ = undefined_;
38
+
39
+ function constant(value) {
40
+ return function (blob) {
41
+ return blob === value ? Result.ok(value) : Result.err((0, _annotate.annotate)(blob, "Must be constant " + String(value)));
42
+ };
43
+ }
44
+ /**
45
+ * Decoder that always returns Ok for the given hardcoded value, no matter what the input.
46
+ */
47
+
48
+
49
+ function hardcoded(value) {
50
+ return function () {
51
+ return Result.ok(value);
52
+ };
53
+ }
54
+ /**
55
+ * Decoder that always returns Ok for the given hardcoded value, no matter what the input.
56
+ */
57
+
58
+
59
+ var unknown = function unknown(blob) {
60
+ return Result.ok(blob);
61
+ };
62
+ /**
63
+ * Alias of unknown.
64
+ */
65
+
66
+
67
+ exports.unknown = unknown;
68
+ var mixed = unknown;
69
+ exports.mixed = mixed;
@@ -1,21 +1,22 @@
1
1
  // @flow strict
2
2
 
3
- import { annotate } from 'debrief';
4
- import { Err, Ok } from 'lemons/Result';
5
-
6
- import type { Decoder, Scalar } from './types';
3
+ import * as Result from '../result';
4
+ import { annotate } from '../annotate';
5
+ import type { Decoder, Scalar } from '../_types';
7
6
 
8
7
  /**
9
8
  * Decoder that only returns Ok for `null` inputs. Err otherwise.
10
9
  */
11
10
  export const null_: Decoder<null> = (blob: mixed) =>
12
- blob === null ? Ok(blob) : Err(annotate(blob, 'Must be null'));
11
+ blob === null ? Result.ok(blob) : Result.err(annotate(blob, 'Must be null'));
13
12
 
14
13
  /**
15
14
  * Decoder that only returns Ok for `undefined` inputs. Err otherwise.
16
15
  */
17
16
  export const undefined_: Decoder<void> = (blob: mixed) =>
18
- blob === undefined ? Ok(blob) : Err(annotate(blob, 'Must be undefined'));
17
+ blob === undefined
18
+ ? Result.ok(blob)
19
+ : Result.err(annotate(blob, 'Must be undefined'));
19
20
 
20
21
  /**
21
22
  * Decoder that only returns Ok for the given value constant. Err otherwise.
@@ -23,23 +24,23 @@ export const undefined_: Decoder<void> = (blob: mixed) =>
23
24
  export function constant<T: Scalar>(value: T): Decoder<T> {
24
25
  return (blob: mixed) =>
25
26
  blob === value
26
- ? Ok(value)
27
- : Err(annotate(blob, `Must be constant ${String(value)}`));
27
+ ? Result.ok(value)
28
+ : Result.err(annotate(blob, `Must be constant ${String(value)}`));
28
29
  }
29
30
 
30
31
  /**
31
32
  * Decoder that always returns Ok for the given hardcoded value, no matter what the input.
32
33
  */
33
34
  export function hardcoded<T>(value: T): Decoder<T> {
34
- return (_: mixed) => Ok(value);
35
+ return () => Result.ok(value);
35
36
  }
36
37
 
37
38
  /**
38
39
  * Decoder that always returns Ok for the given hardcoded value, no matter what the input.
39
40
  */
40
- export const mixed: Decoder<mixed> = (blob: mixed) => Ok((blob: mixed));
41
+ export const unknown: Decoder<mixed> = (blob: mixed) => Result.ok(blob);
41
42
 
42
43
  /**
43
- * Alias of mixed.
44
+ * Alias of unknown.
44
45
  */
45
- export const unknown = mixed;
46
+ export const mixed: Decoder<mixed> = unknown;
@@ -0,0 +1,46 @@
1
+ "use strict";
2
+
3
+ exports.__esModule = true;
4
+ exports.iso8601 = exports.date = void 0;
5
+
6
+ var Result = _interopRequireWildcard(require("../result"));
7
+
8
+ var _annotate = require("../annotate");
9
+
10
+ var _utils = require("../_utils");
11
+
12
+ var _composition = require("./composition");
13
+
14
+ var _string = require("./string");
15
+
16
+ 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); }
17
+
18
+ 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; }
19
+
20
+ // Only matches the shape. This "over-matches" some values that still aren't
21
+ // valid dates (like 9999-99-99), but those will be caught by JS Date's
22
+ // internal validations
23
+ var iso8601_re = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:[.]\d+)?(?:Z|[+-]\d{2}:?\d{2})$/;
24
+
25
+ var date = function date(value) {
26
+ return (0, _utils.isDate)(value) ? Result.ok(value) : Result.err((0, _annotate.annotate)(value, 'Must be a Date'));
27
+ };
28
+ /**
29
+ * Decoder that only returns Ok for strings that are valid ISO8601 date
30
+ * strings. Err otherwise.
31
+ */
32
+
33
+
34
+ exports.date = date;
35
+ var iso8601 = (0, _composition.map)( // Input itself needs to match the ISO8601 regex...
36
+ (0, _string.regex)(iso8601_re, 'Must be ISO8601 format'), // Make sure it is a _valid_ date
37
+ function (value) {
38
+ var date = new Date(value);
39
+
40
+ if (isNaN(date.getTime())) {
41
+ throw new Error('Must be valid date/time value');
42
+ }
43
+
44
+ return date;
45
+ });
46
+ exports.iso8601 = iso8601;
@@ -1,11 +1,11 @@
1
1
  // @flow strict
2
2
 
3
- import { annotate } from 'debrief';
4
- import { Err, Ok } from 'lemons/Result';
5
-
3
+ import * as Result from '../result';
4
+ import { annotate } from '../annotate';
5
+ import { isDate } from '../_utils';
6
+ import { map } from './composition';
6
7
  import { regex } from './string';
7
- import type { Decoder } from './types';
8
- import { isDate, map } from './utils';
8
+ import type { Decoder } from '../_types';
9
9
 
10
10
  // $FlowFixMe[unclear-type] (not really an issue) - deliberate casting
11
11
  type cast = any;
@@ -17,7 +17,9 @@ const iso8601_re =
17
17
  /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:[.]\d+)?(?:Z|[+-]\d{2}:?\d{2})$/;
18
18
 
19
19
  export const date: Decoder<Date> = (value: mixed) =>
20
- isDate(value) ? Ok(((value: cast): Date)) : Err(annotate(value, 'Must be a Date'));
20
+ isDate(value)
21
+ ? Result.ok(((value: cast): Date))
22
+ : Result.err(annotate(value, 'Must be a Date'));
21
23
 
22
24
  /**
23
25
  * Decoder that only returns Ok for strings that are valid ISO8601 date
@@ -34,5 +36,5 @@ export const iso8601: Decoder<Date> = map(
34
36
  throw new Error('Must be valid date/time value');
35
37
  }
36
38
  return date;
37
- }
39
+ },
38
40
  );
@@ -0,0 +1,26 @@
1
+ "use strict";
2
+
3
+ exports.__esModule = true;
4
+ exports.describe = describe;
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
+ * Wrap another decoder, and override the error message in case it fails. This
16
+ * is useful to "simplify" otherwise potentially complex error messages, or to
17
+ * use language in those error messages that can be relayed to end users (for
18
+ * example to show in form errors).
19
+ */
20
+ function describe(decoder, message) {
21
+ return function (blob) {
22
+ return Result.mapError(decoder(blob), function (err) {
23
+ return (0, _annotate.annotate)(err, message);
24
+ });
25
+ };
26
+ }
@@ -1,8 +1,8 @@
1
1
  // @flow strict
2
2
 
3
- import { annotate } from 'debrief';
4
-
5
- import type { Decoder } from './types';
3
+ import * as Result from '../result';
4
+ import { annotate } from '../annotate';
5
+ import type { Decoder } from '../_types';
6
6
 
7
7
  /**
8
8
  * Wrap another decoder, and override the error message in case it fails. This
@@ -12,6 +12,6 @@ import type { Decoder } from './types';
12
12
  */
13
13
  export function describe<T>(decoder: Decoder<T>, message: string): Decoder<T> {
14
14
  return (blob: mixed) => {
15
- return decoder(blob).mapError((err) => annotate(err, message));
15
+ return Result.mapError(decoder(blob), (err) => annotate(err, message));
16
16
  };
17
17
  }
@@ -0,0 +1,62 @@
1
+ "use strict";
2
+
3
+ exports.__esModule = true;
4
+ exports.dispatch = dispatch;
5
+
6
+ var Result = _interopRequireWildcard(require("../result"));
7
+
8
+ var _object2 = require("./object");
9
+
10
+ var _either = require("./either");
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
+ /**
17
+ * Dispatches to one of several given decoders, based on the value found at
18
+ * runtime in the given field. For example, suppose you have these decoders:
19
+ *
20
+ * const rectangle = object({
21
+ * type: constant('rect'),
22
+ * x: number,
23
+ * y: number,
24
+ * width: number,
25
+ * height: number,
26
+ * });
27
+ *
28
+ * const circle = object({
29
+ * type: constant('circle'),
30
+ * cx: number,
31
+ * cy: number,
32
+ * r: number,
33
+ * });
34
+ *
35
+ * Then these two decoders are equivalent:
36
+ *
37
+ * const shape = either(rectangle, circle)
38
+ * const shape = dispatch('type', { rectangle, circle })
39
+ *
40
+ * Will be of type Decoder<Rectangle | Circle>.
41
+ *
42
+ * But the dispatch version will typically be more runtime-efficient. The
43
+ * reason is that it will first do minimal work to "look ahead" into the `type`
44
+ * field here, and based on that value, pick the decoder to invoke.
45
+ *
46
+ * The `either` version will simply try to invoke each decoder, until it finds
47
+ * one that matches.
48
+ *
49
+ * Also, the error messages will be less ambiguous using `dispatch()`.
50
+ */
51
+ function dispatch(field, mapping) {
52
+ var _object;
53
+
54
+ var base = (0, _object2.object)((_object = {}, _object[field] = (0, _either.oneOf)(Object.keys(mapping)), _object));
55
+ return function (blob) {
56
+ return Result.andThen(base(blob), function (baseObj) {
57
+ var decoderName = baseObj[field];
58
+ var decoder = mapping[decoderName];
59
+ return decoder(blob);
60
+ });
61
+ };
62
+ }
@@ -1,8 +1,9 @@
1
1
  // @flow strict
2
2
 
3
- import { oneOf } from './either';
3
+ import * as Result from '../result';
4
4
  import { object } from './object';
5
- import type { $DecoderType, Decoder } from './types';
5
+ import { oneOf } from './either';
6
+ import type { Decoder, DecoderType } from '../_types';
6
7
 
7
8
  // $FlowFixMe[unclear-type] (not really an issue) - deliberate use of `any` - not sure how we should get rid of this
8
9
  type anything = any;
@@ -44,11 +45,11 @@ type anything = any;
44
45
  */
45
46
  export function dispatch<O: { +[field: string]: Decoder<anything>, ... }>(
46
47
  field: string,
47
- mapping: O
48
- ): Decoder<$Values<$ObjMap<O, $DecoderType>>> {
48
+ mapping: O,
49
+ ): Decoder<$Values<$ObjMap<O, DecoderType>>> {
49
50
  const base = object({ [field]: oneOf(Object.keys(mapping)) });
50
51
  return (blob: mixed) => {
51
- return base(blob).andThen((baseObj) => {
52
+ return Result.andThen(base(blob), (baseObj) => {
52
53
  const decoderName = baseObj[field];
53
54
  const decoder = mapping[decoderName];
54
55
  return decoder(blob);
@@ -0,0 +1,117 @@
1
+ "use strict";
2
+
3
+ exports.__esModule = true;
4
+ exports.either = either;
5
+ exports.either3 = either3;
6
+ exports.either4 = either4;
7
+ exports.either5 = either5;
8
+ exports.either6 = either6;
9
+ exports.either7 = either7;
10
+ exports.either8 = either8;
11
+ exports.either9 = either9;
12
+ exports.oneOf = oneOf;
13
+
14
+ var Result = _interopRequireWildcard(require("../result"));
15
+
16
+ var _annotate = require("../annotate");
17
+
18
+ var _utils = require("../_utils");
19
+
20
+ 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); }
21
+
22
+ 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; }
23
+
24
+ /**
25
+ * Indents and adds a dash in front of this (potentially multiline) string.
26
+ */
27
+ function itemize(s) {
28
+ return '-' + (0, _utils.indent)(s).substring(1);
29
+ }
30
+ /**
31
+ * Nests another error as an item under a new-to-be-created "Either error". If
32
+ * the given subitem already is an "Either error" of itself, don't indent, but
33
+ * just "inject" its items at the same error level, for nicely flattened either
34
+ * expressions.
35
+ *
36
+ * Avoids:
37
+ *
38
+ * Either:
39
+ * - Either:
40
+ * - Must be P
41
+ * - Either:
42
+ * - Must be Q
43
+ * - Must be R
44
+ * - Must be S
45
+ *
46
+ * And "flattens" these to:
47
+ *
48
+ * Either:
49
+ * - Must be P
50
+ * - Must be Q
51
+ * - Must be R
52
+ * - Must be S
53
+ *
54
+ */
55
+
56
+
57
+ function nest(errText) {
58
+ var EITHER_PREFIX = 'Either:\n';
59
+ return errText.startsWith(EITHER_PREFIX) ? errText.substr(EITHER_PREFIX.length) : itemize(errText);
60
+ }
61
+
62
+ function either(d1, d2) {
63
+ return function (blob) {
64
+ return Result.orElse(d1(blob), function (err1) {
65
+ return Result.orElse(d2(blob), function (err2) {
66
+ var serr1 = (0, _utils.summarize)(err1).join('\n');
67
+ var serr2 = (0, _utils.summarize)(err2).join('\n');
68
+ var text = ['Either:', nest(serr1), nest(serr2)].join('\n');
69
+ return Result.err((0, _annotate.annotate)(blob, text));
70
+ });
71
+ });
72
+ };
73
+ }
74
+
75
+ function either3(d1, d2, d3) {
76
+ return either(d1, either(d2, d3));
77
+ }
78
+
79
+ function either4(d1, d2, d3, d4) {
80
+ return either(d1, either3(d2, d3, d4));
81
+ }
82
+
83
+ function either5(d1, d2, d3, d4, d5) {
84
+ return either(d1, either4(d2, d3, d4, d5));
85
+ }
86
+
87
+ function either6(d1, d2, d3, d4, d5, d6) {
88
+ return either(d1, either5(d2, d3, d4, d5, d6));
89
+ }
90
+
91
+ function either7(d1, d2, d3, d4, d5, d6, d7) {
92
+ return either(d1, either6(d2, d3, d4, d5, d6, d7));
93
+ }
94
+
95
+ function either8(d1, d2, d3, d4, d5, d6, d7, d8) {
96
+ return either(d1, either7(d2, d3, d4, d5, d6, d7, d8));
97
+ }
98
+
99
+ function either9(d1, d2, d3, d4, d5, d6, d7, d8, d9) {
100
+ return either(d1, either8(d2, d3, d4, d5, d6, d7, d8, d9));
101
+ }
102
+
103
+ function oneOf(constants) {
104
+ return function (blob) {
105
+ var winner = constants.find(function (c) {
106
+ return c === blob;
107
+ });
108
+
109
+ if (winner !== undefined) {
110
+ return Result.ok(winner);
111
+ }
112
+
113
+ return Result.err((0, _annotate.annotate)(blob, "Must be one of " + constants.map(function (value) {
114
+ return JSON.stringify(value);
115
+ }).join(', ')));
116
+ };
117
+ }