decoders 1.25.5 → 2.0.0-beta2

package/_esm/core/either.js

@@ -0,0 +1,90 @@
+import * as Result from '../result';
+import { annotate } from '../annotate';
+import { indent, summarize } from '../_utils';
+
+/**
+ * Indents and adds a dash in front of this (potentially multiline) string.
+ */
+function itemize(s) {
+  return '-' + indent(s).substring(1);
+}
+/**
+ * Nests another error as an item under a new-to-be-created "Either error". If
+ * the given subitem already is an "Either error" of itself, don't indent, but
+ * just "inject" its items at the same error level, for nicely flattened either
+ * expressions.
+ *
+ * Avoids:
+ *
+ *     Either:
+ *     - Either:
+ *       - Must be P
+ *       - Either:
+ *         - Must be Q
+ *         - Must be R
+ *     - Must be S
+ *
+ * And "flattens" these to:
+ *
+ *     Either:
+ *     - Must be P
+ *     - Must be Q
+ *     - Must be R
+ *     - Must be S
+ *
+ */
+
+
+function nest(errText) {
+  var EITHER_PREFIX = 'Either:\n';
+  return errText.startsWith(EITHER_PREFIX) ? errText.substr(EITHER_PREFIX.length) : itemize(errText);
+}
+
+export function either(d1, d2) {
+  return function (blob) {
+    return Result.orElse(d1(blob), function (err1) {
+      return Result.orElse(d2(blob), function (err2) {
+        var serr1 = summarize(err1).join('\n');
+        var serr2 = summarize(err2).join('\n');
+        var text = ['Either:', nest(serr1), nest(serr2)].join('\n');
+        return Result.err(annotate(blob, text));
+      });
+    });
+  };
+}
+export function either3(d1, d2, d3) {
+  return either(d1, either(d2, d3));
+}
+export function either4(d1, d2, d3, d4) {
+  return either(d1, either3(d2, d3, d4));
+}
+export function either5(d1, d2, d3, d4, d5) {
+  return either(d1, either4(d2, d3, d4, d5));
+}
+export function either6(d1, d2, d3, d4, d5, d6) {
+  return either(d1, either5(d2, d3, d4, d5, d6));
+}
+export function either7(d1, d2, d3, d4, d5, d6, d7) {
+  return either(d1, either6(d2, d3, d4, d5, d6, d7));
+}
+export function either8(d1, d2, d3, d4, d5, d6, d7, d8) {
+  return either(d1, either7(d2, d3, d4, d5, d6, d7, d8));
+}
+export function either9(d1, d2, d3, d4, d5, d6, d7, d8, d9) {
+  return either(d1, either8(d2, d3, d4, d5, d6, d7, d8, d9));
+}
+export function oneOf(constants) {
+  return function (blob) {
+    var winner = constants.find(function (c) {
+      return c === blob;
+    });
+
+    if (winner !== undefined) {
+      return Result.ok(winner);
+    }
+
+    return Result.err(annotate(blob, "Must be one of " + constants.map(function (value) {
+      return JSON.stringify(value);
+    }).join(', ')));
+  };
+}

package/{either.js.flow → _esm/core/either.js.flow}

@@ -1,45 +1,65 @@
 // @flow strict
 
-import { annotate, indent } from 'debrief';
-import { summarize } from 'debrief';
-import { Err, Ok } from 'lemons/Result';
-
-import type { Decoder, Scalar } from './types';
+import * as Result from '../result';
+import { annotate } from '../annotate';
+import { indent, summarize } from '../_utils';
+import type { Decoder, Scalar } from '../_types';
 
 /**
  * Indents and adds a dash in front of this (potentially multiline) string.
  */
-// istanbul ignore next
-function itemize(s: string = ''): string {
+function itemize(s: string): string {
     return '-' + indent(s).substring(1);
 }
 
+/**
+ * Nests another error as an item under a new-to-be-created "Either error". If
+ * the given subitem already is an "Either error" of itself, don't indent, but
+ * just "inject" its items at the same error level, for nicely flattened either
+ * expressions.
+ *
+ * Avoids:
+ *
+ *     Either:
+ *     - Either:
+ *       - Must be P
+ *       - Either:
+ *         - Must be Q
+ *         - Must be R
+ *     - Must be S
+ *
+ * And "flattens" these to:
+ *
+ *     Either:
+ *     - Must be P
+ *     - Must be Q
+ *     - Must be R
+ *     - Must be S
+ *
+ */
+function nest(errText: string): string {
+    const EITHER_PREFIX = 'Either:\n';
+    return errText.startsWith(EITHER_PREFIX)
+        ? errText.substr(EITHER_PREFIX.length)
+        : itemize(errText);
+}
+
 export function either<T1, T2>(d1: Decoder<T1>, d2: Decoder<T2>): Decoder<T1 | T2> {
     return (blob: mixed) =>
-        d1(blob).dispatch(
-            (value1) => Ok(value1),
-            (err1) =>
-                d2(blob).dispatch(
-                    (value2) => Ok(value2),
-                    (err2) =>
-                        Err(
-                            annotate(
-                                blob,
-                                [
-                                    'Either:',
-                                    itemize(summarize(err1).join('\n')),
-                                    itemize(summarize(err2).join('\n')),
-                                ].join('\n')
-                            )
-                        )
-                )
+        Result.orElse(d1(blob), (err1) =>
+            Result.orElse(d2(blob), (err2) => {
+                const serr1 = summarize(err1).join('\n');
+                const serr2 = summarize(err2).join('\n');
+                const text = ['Either:', nest(serr1), nest(serr2)].join('\n');
+                return Result.err(annotate(blob, text));
+            }),
         );
 }
 
 export function either3<T1, T2, T3>(
     d1: Decoder<T1>,
     d2: Decoder<T2>,
-    d3: Decoder<T3>
+    d3: Decoder<T3>,
 ): Decoder<T1 | T2 | T3> {
     return either(d1, either(d2, d3));
 }
@@ -48,7 +68,7 @@ export function either4<T1, T2, T3, T4>(
     d1: Decoder<T1>,
     d2: Decoder<T2>,
     d3: Decoder<T3>,
-    d4: Decoder<T4>
+    d4: Decoder<T4>,
 ): Decoder<T1 | T2 | T3 | T4> {
     return either(d1, either3(d2, d3, d4));
 }
@@ -58,7 +78,7 @@ export function either5<T1, T2, T3, T4, T5>(
     d2: Decoder<T2>,
     d3: Decoder<T3>,
     d4: Decoder<T4>,
-    d5: Decoder<T5>
+    d5: Decoder<T5>,
 ): Decoder<T1 | T2 | T3 | T4 | T5> {
     return either(d1, either4(d2, d3, d4, d5));
 }
@@ -69,7 +89,7 @@ export function either6<T1, T2, T3, T4, T5, T6>(
     d3: Decoder<T3>,
     d4: Decoder<T4>,
     d5: Decoder<T5>,
-    d6: Decoder<T6>
+    d6: Decoder<T6>,
 ): Decoder<T1 | T2 | T3 | T4 | T5 | T6> {
     return either(d1, either5(d2, d3, d4, d5, d6));
 }
@@ -81,7 +101,7 @@ export function either7<T1, T2, T3, T4, T5, T6, T7>(
     d4: Decoder<T4>,
     d5: Decoder<T5>,
     d6: Decoder<T6>,
-    d7: Decoder<T7>
+    d7: Decoder<T7>,
 ): Decoder<T1 | T2 | T3 | T4 | T5 | T6 | T7> {
     return either(d1, either6(d2, d3, d4, d5, d6, d7));
 }
@@ -94,7 +114,7 @@ export function either8<T1, T2, T3, T4, T5, T6, T7, T8>(
     d5: Decoder<T5>,
     d6: Decoder<T6>,
     d7: Decoder<T7>,
-    d8: Decoder<T8>
+    d8: Decoder<T8>,
 ): Decoder<T1 | T2 | T3 | T4 | T5 | T6 | T7 | T8> {
     return either(d1, either7(d2, d3, d4, d5, d6, d7, d8));
 }
@@ -108,7 +128,7 @@ export function either9<T1, T2, T3, T4, T5, T6, T7, T8, T9>(
     d6: Decoder<T6>,
     d7: Decoder<T7>,
     d8: Decoder<T8>,
-    d9: Decoder<T9>
+    d9: Decoder<T9>,
 ): Decoder<T1 | T2 | T3 | T4 | T5 | T6 | T7 | T8 | T9> {
     return either(d1, either8(d2, d3, d4, d5, d6, d7, d8, d9));
 }
@@ -117,15 +137,15 @@ export function oneOf<T: Scalar>(constants: $ReadOnlyArray<T>): Decoder<T> {
     return (blob: mixed) => {
         const winner = constants.find((c) => c === blob);
         if (winner !== undefined) {
-            return Ok(winner);
+            return Result.ok(winner);
         }
-        return Err(
+        return Result.err(
             annotate(
                 blob,
                 `Must be one of ${constants
                     .map((value) => JSON.stringify(value))
-                    .join(', ')}`
-            )
+                    .join(', ')}`,
+            ),
         );
     };
 }

package/_esm/core/fail.js

@@ -0,0 +1,11 @@
+import * as Result from '../result';
+import { annotate } from '../annotate';
+
+/**
+ * Decoder that always fails with the given error message, no matter what the input.
+ */
+export function fail(msg) {
+  return function (blob) {
+    return Result.err(annotate(blob, msg));
+  };
+}

package/_esm/core/fail.js.flow

@@ -0,0 +1,12 @@
+// @flow strict
+
+import * as Result from '../result';
+import { annotate } from '../annotate';
+import type { Decoder } from '../_types';
+
+/**
+ * Decoder that always fails with the given error message, no matter what the input.
+ */
+export function fail(msg: string): Decoder<empty> {
+    return (blob: mixed) => Result.err(annotate(blob, msg));
+}

package/_esm/core/instanceOf.js

@@ -0,0 +1,8 @@
+import * as Result from '../result';
+import { annotate } from '../annotate';
+export function instanceOf(klass) {
+  return function (blob) {
+    return blob instanceof klass ? Result.ok(blob) : Result.err(annotate(blob, "Must be " + // $FlowFixMe[incompatible-use] - klass.name is fine?
+    klass.name + " instance"));
+  };
+}

package/{instanceOf.js.flow → _esm/core/instanceOf.js.flow}

@@ -1,21 +1,20 @@
 // @flow strict
 
-import { annotate } from 'debrief';
-import { Err, Ok } from 'lemons/Result';
-
-import type { Decoder } from './types';
+import * as Result from '../result';
+import { annotate } from '../annotate';
+import type { Decoder } from '../_types';
 
 export function instanceOf<T>(klass: Class<T>): Decoder<T> {
     return (blob: mixed) =>
         blob instanceof klass
-            ? Ok(blob)
-            : Err(
+            ? Result.ok(blob)
+            : Result.err(
                   annotate(
                       blob,
                       `Must be ${
                           // $FlowFixMe[incompatible-use] - klass.name is fine?
                           klass.name
-                      } instance`
-                  )
+                      } instance`,
+                  ),
               );
 }

package/_esm/core/json.js

@@ -0,0 +1,15 @@
+import { array } from './array';
+import { boolean as _boolean } from './boolean';
+import { dict } from './mapping';
+import { either6 } from './either';
+import { lazy } from './lazy';
+import { null_ } from './constants';
+import { number } from './number';
+import { string } from './string';
+export var jsonObject = lazy(function () {
+  return dict(json);
+});
+export var jsonArray = lazy(function () {
+  return array(json);
+});
+export var json = either6(null_, string, number, _boolean, jsonObject, jsonArray);

package/{json.js.flow → _esm/core/json.js.flow}

@@ -2,13 +2,13 @@
 
 import { array } from './array';
 import { boolean } from './boolean';
-import { null_ } from './constants';
+import { dict } from './mapping';
 import { either6 } from './either';
 import { lazy } from './lazy';
-import { dict } from './mapping';
+import { null_ } from './constants';
 import { number } from './number';
 import { string } from './string';
-import type { Decoder } from './types';
+import type { Decoder } from '../_types';
 
 export type JSONValue = null | string | number | boolean | JSONObject | JSONArray;
 export type JSONObject = { [string]: JSONValue };
@@ -24,5 +24,5 @@ export const json: Decoder<JSONValue> = either6(
     number,
     boolean,
     jsonObject,
-    jsonArray
+    jsonArray,
 );

package/_esm/core/lazy.js

@@ -0,0 +1,11 @@
+/**
+ * Given an function returning a Decoder, will use that decoder to decode the
+ * value. This is typically used to build decoders for recursive or
+ * self-referential types.
+ */
+export function lazy(decoderFn) {
+  return function (blob) {
+    var decoder = decoderFn();
+    return decoder(blob);
+  };
+}

package/{lazy.js.flow → _esm/core/lazy.js.flow}

@@ -1,6 +1,6 @@
 // @flow strict
 
-import type { Decoder } from './types';
+import type { Decoder } from '../_types';
 
 /**
  * Given an function returning a Decoder, will use that decoder to decode the

package/_esm/core/mapping.js

@@ -0,0 +1,54 @@
+import * as Result from '../result';
+import { annotateObject } from '../annotate';
+import { compose, map } from './composition';
+import { merge } from '../annotate';
+import { pojo } from './object';
+
+/**
+ * Given an object, will decode a Map of string keys to whatever values.
+ *
+ * For example, given a decoder for a Person, we can verify a Person lookup
+ * table structure (of type Map<string, Person>) like so:
+ *
+ *   mapping(person)
+ *
+ */
+export function mapping(decoder) {
+  return compose(pojo, function (blob) {
+    var tuples = [];
+    var errors = null;
+    Object.keys(blob).forEach(function (key) {
+      var value = blob[key];
+      var result = decoder(value);
+
+      if (result.type === 'ok') {
+        if (errors === null) {
+          tuples.push([key, result.value]);
+        }
+      } else {
+        tuples.length = 0; // Clear the tuples array
+
+        if (errors === null) {
+          errors = {};
+        }
+
+        errors[key] = result.error;
+      }
+    });
+
+    if (errors !== null) {
+      return Result.err(merge(annotateObject(blob), errors));
+    } else {
+      return Result.ok(new Map(tuples));
+    }
+  });
+}
+/**
+ * Like mapping(), but returns an object rather than a Map instance.
+ */
+
+export function dict(decoder) {
+  return map(mapping(decoder), function (m) {
+    return Object.fromEntries(m);
+  });
+}

package/_esm/core/mapping.js.flow

@@ -0,0 +1,54 @@
+// @flow strict
+
+import * as Result from '../result';
+import { annotateObject } from '../annotate';
+import { compose, map } from './composition';
+import { merge } from '../annotate';
+import { pojo } from './object';
+import type { Annotation } from '../annotate';
+import type { Decoder } from '../_types';
+
+/**
+ * Given an object, will decode a Map of string keys to whatever values.
+ *
+ * For example, given a decoder for a Person, we can verify a Person lookup
+ * table structure (of type Map<string, Person>) like so:
+ *
+ *   mapping(person)
+ *
+ */
+export function mapping<T>(decoder: Decoder<T>): Decoder<Map<string, T>> {
+    return compose(pojo, (blob: { +[key: string]: mixed }) => {
+        let tuples: Array<[string, T]> = [];
+        let errors: { [key: string]: Annotation } | null = null;
+
+        Object.keys(blob).forEach((key: string) => {
+            const value = blob[key];
+            const result = decoder(value);
+            if (result.type === 'ok') {
+                if (errors === null) {
+                    tuples.push([key, result.value]);
+                }
+            } else {
+                tuples.length = 0; // Clear the tuples array
+                if (errors === null) {
+                    errors = {};
+                }
+                errors[key] = result.error;
+            }
+        });
+
+        if (errors !== null) {
+            return Result.err(merge(annotateObject(blob), errors));
+        } else {
+            return Result.ok(new Map(tuples));
+        }
+    });
+}
+
+/**
+ * Like mapping(), but returns an object rather than a Map instance.
+ */
+export function dict<T>(decoder: Decoder<T>): Decoder<{ [string]: T }> {
+    return map(mapping(decoder), (m) => Object.fromEntries(m));
+}

package/_esm/core/number.js

@@ -0,0 +1,25 @@
+import * as Result from '../result';
+import { annotate } from '../annotate';
+import { compose, predicate } from './composition';
+
+var anyNumber = function anyNumber(blob) {
+  return typeof blob === 'number' && !Number.isNaN(blob) ? Result.ok(blob) : Result.err(annotate(blob, 'Must be number'));
+};
+
+var isInteger = function isInteger(n) {
+  return Number.isInteger(n);
+};
+
+var isFinite = function isFinite(n) {
+  return Number.isFinite(n);
+};
+
+export var number = compose(anyNumber, predicate(isFinite, 'Number must be finite'));
+export var positiveNumber = compose(number, predicate(function (n) {
+  return n >= 0;
+}, 'Number must be positive')); // Integers
+
+export var integer = compose(number, predicate(isInteger, 'Number must be an integer'));
+export var positiveInteger = compose(integer, predicate(function (n) {
+  return n >= 0;
+}, 'Number must be positive'));

package/{number.js.flow → _esm/core/number.js.flow}

@@ -1,15 +1,14 @@
 // @flow strict
 
-import { annotate } from 'debrief';
-import { Err, Ok } from 'lemons/Result';
-
-import type { Decoder } from './types';
-import { compose, predicate } from './utils';
+import * as Result from '../result';
+import { annotate } from '../annotate';
+import { compose, predicate } from './composition';
+import type { Decoder } from '../_types';
 
 const anyNumber: Decoder<number> = (blob: mixed) => {
     return typeof blob === 'number' && !Number.isNaN(blob)
-        ? Ok(blob)
-        : Err(annotate(blob, 'Must be number'));
+        ? Result.ok(blob)
+        : Result.err(annotate(blob, 'Must be number'));
 };
 
 const isInteger = (n: number) => Number.isInteger(n);
@@ -17,19 +16,19 @@ const isFinite = (n: number) => Number.isFinite(n);
 
 export const number: Decoder<number> = compose(
     anyNumber,
-    predicate(isFinite, 'Number must be finite')
+    predicate(isFinite, 'Number must be finite'),
 );
 export const positiveNumber: Decoder<number> = compose(
     number,
-    predicate((n) => n >= 0, 'Number must be positive')
+    predicate((n) => n >= 0, 'Number must be positive'),
 );
 
 // Integers
 export const integer: Decoder<number> = compose(
     number,
-    predicate(isInteger, 'Number must be an integer')
+    predicate(isInteger, 'Number must be an integer'),
 );
 export const positiveInteger: Decoder<number> = compose(
     integer,
-    predicate((n) => n >= 0, 'Number must be positive')
+    predicate((n) => n >= 0, 'Number must be positive'),
 );