decoders 2.0.0-beta1 → 2.0.0-beta13

package/es/stdlib/boolean.js

@@ -1,28 +0,0 @@
-import * as Result from '../result';
-import { annotate } from '../annotate';
-import { map } from './composition';
-import { number } from './number';
-
-/**
- * Decoder that only returns Ok for boolean inputs.  Err otherwise.
- */
-var _boolean = function _boolean(blob) {
-  return typeof blob === 'boolean' ? Result.ok(blob) : Result.err(annotate(blob, 'Must be boolean'));
-};
-/**
- * Decoder that returns true for all truthy values, and false otherwise.  Never fails.
- */
-
-
-export { _boolean as boolean };
-export var truthy = function truthy(blob) {
-  return Result.ok(!!blob);
-};
-/**
- * Decoder that only returns Ok for numeric input values representing booleans.
- * Returns their boolean representation.  Err otherwise.
- */
-
-export var numericBoolean = map(number, function (n) {
-  return !!n;
-});

package/es/stdlib/composition.js

@@ -1,42 +0,0 @@
-import * as Result from '../result';
-import { annotate } from '../annotate';
-
-/**
- * Given a decoder T and a mapping function from T's to V's, returns a decoder
- * for V's.  This is useful to change the original input data.
- */
-export function map(decoder, mapper) {
-  return compose(decoder, function (x) {
-    try {
-      return Result.ok(mapper(x));
-    } catch (e) {
-      return Result.err(annotate(x, e instanceof Error ? e.message : String(e)));
-    }
-  });
-}
-/**
- * Compose two decoders by passing the result of the first into the second.
- * The second decoder may assume as its input type the output type of the first
- * decoder (so it's not necessary to accept the typical "mixed").  This is
- * useful for "narrowing down" the checks.  For example, if you want to write
- * a decoder for positive numbers, you can compose it from an existing decoder
- * for any number, and a decoder that, assuming a number, checks if it's
- * positive.  Very often combined with the predicate() helper as the second
- * argument.
- */
-
-export function compose(decoder, next) {
-  return function (blob) {
-    return Result.andThen(decoder(blob), next);
-  };
-}
-/**
- * Factory function returning a Decoder<T>, given a predicate function that
- * accepts/rejects the input of type T.
- */
-
-export function predicate(predicate, msg) {
-  return function (value) {
-    return predicate(value) ? Result.ok(value) : Result.err(annotate(value, msg));
-  };
-}

package/es/stdlib/constants.js

@@ -1,46 +0,0 @@
-import * as Result from '../result';
-import { annotate } from '../annotate';
-
-/**
- * Decoder that only returns Ok for `null` inputs.  Err otherwise.
- */
-export var null_ = function null_(blob) {
-  return blob === null ? Result.ok(blob) : Result.err(annotate(blob, 'Must be null'));
-};
-/**
- * Decoder that only returns Ok for `undefined` inputs.  Err otherwise.
- */
-
-export var undefined_ = function undefined_(blob) {
-  return blob === undefined ? Result.ok(blob) : Result.err(annotate(blob, 'Must be undefined'));
-};
-/**
- * Decoder that only returns Ok for the given value constant.  Err otherwise.
- */
-
-export function constant(value) {
-  return function (blob) {
-    return blob === value ? Result.ok(value) : Result.err(annotate(blob, "Must be constant " + String(value)));
-  };
-}
-/**
- * Decoder that always returns Ok for the given hardcoded value, no matter what the input.
- */
-
-export function hardcoded(value) {
-  return function () {
-    return Result.ok(value);
-  };
-}
-/**
- * Decoder that always returns Ok for the given hardcoded value, no matter what the input.
- */
-
-export var unknown = function unknown(blob) {
-  return Result.ok(blob);
-};
-/**
- * Alias of unknown.
- */
-
-export var mixed = unknown;

package/es/stdlib/date.js

@@ -1,28 +0,0 @@
-import * as Result from '../result';
-import { annotate } from '../annotate';
-import { isDate } from '../_utils';
-import { map } from './composition';
-import { regex } from './string';
-// Only matches the shape.  This "over-matches" some values that still aren't
-// valid dates (like 9999-99-99), but those will be caught by JS Date's
-// internal validations
-var iso8601_re = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:[.]\d+)?(?:Z|[+-]\d{2}:?\d{2})$/;
-export var date = function date(value) {
-  return isDate(value) ? Result.ok(value) : Result.err(annotate(value, 'Must be a Date'));
-};
-/**
- * Decoder that only returns Ok for strings that are valid ISO8601 date
- * strings.  Err otherwise.
- */
-
-export var iso8601 = map( // Input itself needs to match the ISO8601 regex...
-regex(iso8601_re, 'Must be ISO8601 format'), // Make sure it is a _valid_ date
-function (value) {
-  var date = new Date(value);
-
-  if (isNaN(date.getTime())) {
-    throw new Error('Must be valid date/time value');
-  }
-
-  return date;
-});

package/es/stdlib/describe.js

@@ -1,16 +0,0 @@
-import * as Result from '../result';
-import { annotate } from '../annotate';
-
-/**
- * Wrap another decoder, and override the error message in case it fails. This
- * is useful to "simplify" otherwise potentially complex error messages, or to
- * use language in those error messages that can be relayed to end users (for
- * example to show in form errors).
- */
-export function describe(decoder, message) {
-  return function (blob) {
-    return Result.mapError(decoder(blob), function (err) {
-      return annotate(err, message);
-    });
-  };
-}

package/es/stdlib/dispatch.js

@@ -1,51 +0,0 @@
-import * as Result from '../result';
-import { object } from './object';
-import { oneOf } from './either';
-
-/**
- * Dispatches to one of several given decoders, based on the value found at
- * runtime in the given field.  For example, suppose you have these decoders:
- *
- *     const rectangle = object({
- *         type: constant('rect'),
- *         x: number,
- *         y: number,
- *         width: number,
- *         height: number,
- *     });
- *
- *     const circle = object({
- *         type: constant('circle'),
- *         cx: number,
- *         cy: number,
- *         r: number,
- *      });
- *
- * Then these two decoders are equivalent:
- *
- *     const shape = either(rectangle, circle)
- *     const shape = dispatch('type', { rectangle, circle })
- *
- * Will be of type Decoder<Rectangle | Circle>.
- *
- * But the dispatch version will typically be more runtime-efficient.  The
- * reason is that it will first do minimal work to "look ahead" into the `type`
- * field here, and based on that value, pick the decoder to invoke.
- *
- * The `either` version will simply try to invoke each decoder, until it finds
- * one that matches.
- *
- * Also, the error messages will be less ambiguous using `dispatch()`.
- */
-export function dispatch(field, mapping) {
-  var _object;
-
-  var base = object((_object = {}, _object[field] = oneOf(Object.keys(mapping)), _object));
-  return function (blob) {
-    return Result.andThen(base(blob), function (baseObj) {
-      var decoderName = baseObj[field];
-      var decoder = mapping[decoderName];
-      return decoder(blob);
-    });
-  };
-}

package/es/stdlib/either.js

@@ -1,90 +0,0 @@
-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/es/stdlib/fail.js

@@ -1,11 +0,0 @@
-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/es/stdlib/instanceOf.js

@@ -1,8 +0,0 @@
-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/es/stdlib/json.js

@@ -1,15 +0,0 @@
-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/es/stdlib/lazy.js

@@ -1,11 +0,0 @@
-/**
- * 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/es/stdlib/mapping.js

@@ -1,54 +0,0 @@
-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/es/stdlib/number.js

@@ -1,25 +0,0 @@
-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/es/stdlib/object.js

@@ -1,175 +0,0 @@
-function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
-
-import * as Result from '../result';
-import { annotate, annotateObject, merge, updateText } from '../annotate';
-import { compose, map } from './composition';
-
-function isPojo(o) {
-  return o !== null && o !== undefined && typeof o === 'object' && // This still seems to be the only reliable way to determine whether
-  // something is a pojo... ¯\_(ツ)_/¯
-  // $FlowFixMe[method-unbinding]
-  Object.prototype.toString.call(o) === '[object Object]';
-}
-
-function subtract(xs, ys) {
-  var result = new Set();
-  xs.forEach(function (x) {
-    if (!ys.has(x)) {
-      result.add(x);
-    }
-  });
-  return result;
-}
-
-export var pojo = function pojo(blob) {
-  return isPojo(blob) ? Result.ok( // NOTE:
-  // Since Flow 0.98, typeof o === 'object' refines to
-  //     {| +[string]: mixed |}
-  // instead of
-  //     {| [string]: mixed |}
-  //
-  // For rationale, see https://github.com/facebook/flow/issues/7685.
-  // In this case, we don't want to output a read-only version of
-  // the object because it's up to the user of decoders to
-  // determine what they want to do with the decoded output.  If they
-  // want to write items into the array, that's fine!  The fastest
-  // way to turn a read-only Object to a writeable one in ES6 seems
-  // to be to use object-spread. (Going off this benchmark:
-  // https://thecodebarbarian.com/object-assign-vs-object-spread.html)
-  _extends({}, blob)) : Result.err(annotate(blob, 'Must be an object'));
-};
-/**
- * Given a mapping of fields-to-decoders, builds a decoder for an object type.
- *
- * For example, given decoders for a number and a string, we can construct an
- * "object description" like so:
- *
- *   { id: number, name: string }
- *
- * Which is of type:
- *
- *   { id: Decoder<number>, name: Decoder<string> }
- *
- * Passing this to object() will produce the following return type:
- *
- *   Decoder<{ id: number, name: string }>
- *
- * Put simply: it'll "peel off" all of the nested Decoders, puts them together
- * in an object, and wraps it in a Decoder<...>.
- */
-
-export function object(mapping) {
-  var known = new Set(Object.keys(mapping));
-  return compose(pojo, function (blob) {
-    var actual = new Set(Object.keys(blob)); // At this point, "missing" will also include all fields that may
-    // validly be optional.  We'll let the underlying decoder decide and
-    // remove the key from this missing set if the decoder accepts the
-    // value.
-
-    var missing = subtract(known, actual);
-    var record = {};
-    var errors = null;
-    Object.keys(mapping).forEach(function (key) {
-      var decoder = mapping[key];
-      var rawValue = blob[key];
-      var result = decoder(rawValue);
-
-      if (result.type === 'ok') {
-        var value = result.value;
-
-        if (value !== undefined) {
-          record[key] = value;
-        } // If this succeeded, remove the key from the missing keys
-        // tracker
-
-
-        missing["delete"](key);
-      } else {
-        var ann = result.error; // Keep track of the annotation, but don't return just yet. We
-        // want to collect more error information.
-
-        if (rawValue === undefined) {
-          // Explicitly add it to the missing set if the value is
-          // undefined.  This covers explicit undefineds to be
-          // treated the same as implicit undefineds (aka missing
-          // keys).
-          missing.add(key);
-        } else {
-          if (errors === null) {
-            errors = {};
-          }
-
-          errors[key] = ann;
-        }
-      }
-    }); // Deal with errors now. There are two classes of errors we want to
-    // report.  First of all, we want to report any inline errors in this
-    // object.  Lastly, any fields that are missing should be annotated on
-    // the outer object itself.
-
-    if (errors || missing.size > 0) {
-      var objAnn = annotateObject(blob);
-
-      if (errors) {
-        objAnn = merge(objAnn, errors);
-      }
-
-      if (missing.size > 0) {
-        var errMsg = Array.from(missing).map(function (key) {
-          return "\"" + key + "\"";
-        }).join(', ');
-        var pluralized = missing.size > 1 ? 'keys' : 'key';
-        objAnn = updateText(objAnn, "Missing " + pluralized + ": " + errMsg);
-      }
-
-      return Result.err(objAnn);
-    }
-
-    return Result.ok(record);
-  });
-}
-export function exact(mapping) {
-  // Check the inputted object for any superfluous keys
-  var allowed = new Set(Object.keys(mapping));
-  var checked = compose(pojo, function (blob) {
-    var actual = new Set(Object.keys(blob));
-    var superfluous = subtract(actual, allowed);
-
-    if (superfluous.size > 0) {
-      return Result.err(annotate(blob, "Superfluous keys: " + Array.from(superfluous).join(', ')));
-    }
-
-    return Result.ok(blob);
-  }); // Defer to the "object" decoder for doing the real decoding work.  Since
-  // we made sure there are no superfluous keys in this structure, it's now
-  // safe to force-cast it to an $Exact<> type.
-
-  var decoder = object(mapping);
-  return compose(checked, decoder);
-}
-export function inexact(mapping) {
-  return compose(pojo, function (blob) {
-    var allkeys = new Set(Object.keys(blob));
-    var decoder = map(object(mapping), function (safepart) {
-      var safekeys = new Set(Object.keys(mapping)); // To account for hard-coded keys that aren't part of the input
-
-      safekeys.forEach(function (k) {
-        return allkeys.add(k);
-      });
-      var rv = {};
-      allkeys.forEach(function (k) {
-        if (safekeys.has(k)) {
-          var value = safepart[k];
-
-          if (value !== undefined) {
-            rv[k] = value;
-          }
-        } else {
-          rv[k] = blob[k];
-        }
-      });
-      return rv;
-    });
-    return decoder(blob);
-  });
-}

package/es/stdlib/optional.js

@@ -1,38 +0,0 @@
-import * as Result from '../result';
-import { annotate } from '../annotate';
-import { either } from './either';
-import { null_, undefined_ } from './constants';
-
-/**
- * Builds a Decoder that returns Ok for either `undefined` or `T` values,
- * given a Decoder for `T`.  Err otherwise.
- */
-export function optional(decoder) {
-  return either(undefined_, decoder);
-}
-/**
- * Builds a Decoder that returns Ok for either `null` or `T` values,
- * given a Decoder for `T`.  Err otherwise.
- */
-
-export function nullable(decoder) {
-  return either(null_, decoder);
-}
-/**
- * Decoder that only returns Ok for `null` or `undefined` inputs.
- * This is effectively equivalent to either(null_, undefined_), but combines
- * their error message output into a single line for convenience.
- */
-
-var undefined_or_null = function undefined_or_null(blob) {
-  return blob === undefined || blob === null ? Result.ok(blob) : // Combine error message into a single line
-  Result.err(annotate(blob, 'Must be undefined or null'));
-};
-/**
- * Decoder that only returns Ok for `null` or `undefined` inputs.
- */
-
-
-export function maybe(decoder) {
-  return either(undefined_or_null, decoder);
-}