decoders 2.0.0 → 2.0.2

package/lib/arrays.mjs

@@ -1,124 +1,84 @@
-import { annotate } from '../annotate.mjs';
-import { define } from '../Decoder.mjs';
-
-/**
- * Accepts any array, but doesn't validate its items further.
- *
- * "poja" means "plain old JavaScript array", a play on `pojo()`.
- */
+import { annotate } from '../annotate.mjs'
+import { define } from '../Decoder.mjs'
+
 export var poja = define(function (blob, ok, err) {
   if (!Array.isArray(blob)) {
-    return err('Must be an array');
+    return err('Must be an array')
   }
 
-  return ok( // NOTE: Since Flow 0.98, Array.isArray() returns $ReadOnlyArray<mixed>
-  // instead of Array<mixed>.  For rationale, see
-  // https://github.com/facebook/flow/issues/7684.  In this case, we
-  // don't want to output read-only types 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 array into a normal array in
-  // Javascript is to use .slice() on it, see this benchmark:
-  // http://jsben.ch/lO6C5
-  blob.slice());
-});
-/**
- * Given an array of Result instances, loop over them all and return:
- * - An [index, err] tuple, indicating the (index of the) first Err instance
- *   encountered; or
- * - a new Ok with an array of all unwrapped Ok'ed values
- */
-
-function all(items, blobs, // TODO: Make this less ugly
-ok, err) {
-  var results = [];
+  return ok(blob.slice())
+})
+
+function all(items, blobs, ok, err) {
+  var results = []
 
   for (var index = 0; index < items.length; ++index) {
-    var result = items[index];
+    var result = items[index]
 
     if (result.ok) {
-      results.push(result.value);
+      results.push(result.value)
     } else {
-      var ann = result.error; // Rewrite the annotation to include the index information, and inject it into the original blob
+      var ann = result.error
 
-      var clone = [].concat(blobs);
-      clone.splice(index, 1, annotate(ann, ann.text ? ann.text + " (at index " + index + ")" : "index " + index));
-      return err(annotate(clone));
+      var clone = [].concat(blobs)
+      clone.splice(index, 1, annotate(ann, ann.text ? ann.text + ' (at index ' + index + ')' : 'index ' + index))
+      return err(annotate(clone))
     }
   }
 
-  return ok(results);
+  return ok(results)
 }
-/**
- * Accepts arrays of whatever the given decoder accepts.
- */
-
 
 export function array(decoder) {
   return poja.then(function (blobs, ok, err) {
-    var results = blobs.map(decoder.decode);
-    return all(results, blobs, ok, err);
-  });
+    var results = blobs.map(decoder.decode)
+    return all(results, blobs, ok, err)
+  })
 }
-/**
- * Like `array()`, but will reject arrays with 0 elements.
- */
 
 export function nonEmptyArray(decoder) {
   return array(decoder).refine(function (arr) {
-    return arr.length > 0;
-  }, 'Must be non-empty array');
+    return arr.length > 0
+  }, 'Must be non-empty array')
 }
-/**
- * Similar to `array()`, but returns the result as an [ES6
- * Set](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set).
- */
 
 export function set(decoder) {
   return array(decoder).transform(function (items) {
-    return new Set(items);
-  });
+    return new Set(items)
+  })
 }
 
 var ntuple = function ntuple(n) {
   return poja.refine(function (arr) {
-    return arr.length === n;
-  }, "Must be a " + n + "-tuple");
-}; // prettier-ignore
-
+    return arr.length === n
+  }, 'Must be a ' + n + '-tuple')
+}
 
 function _tuple() {
   for (var _len = arguments.length, decoders = new Array(_len), _key = 0; _key < _len; _key++) {
-    decoders[_key] = arguments[_key];
+    decoders[_key] = arguments[_key]
   }
 
   return ntuple(decoders.length).then(function (blobs, ok, err) {
-    var allOk = true;
+    var allOk = true
     var rvs = decoders.map(function (decoder, i) {
-      var blob = blobs[i];
-      var result = decoder.decode(blob);
+      var blob = blobs[i]
+      var result = decoder.decode(blob)
 
       if (result.ok) {
-        return result.value;
+        return result.value
       } else {
-        allOk = false;
-        return result.error;
+        allOk = false
+        return result.error
       }
-    });
+    })
 
     if (allOk) {
-      return ok(rvs);
+      return ok(rvs)
     } else {
-      // If a decoder error has happened while unwrapping all the
-      // results, try to construct a good error message
-      return err(annotate(rvs));
+      return err(annotate(rvs))
     }
-  });
+  })
 }
-/**
- * Accepts a tuple (an array with exactly _n_ items) of values accepted by the
- * _n_ given decoders.
- */
-
 
-export var tuple = _tuple;
+export var tuple = _tuple

package/lib/basics.js

@@ -1,144 +1,94 @@
-"use strict";
+'use strict'
 
-exports.__esModule = true;
-exports.always = always;
-exports.constant = constant;
-exports.unknown = exports.undefined_ = exports.optional = exports.nullable = exports.null_ = exports.mixed = exports.maybe = exports.hardcoded = void 0;
+exports.__esModule = true
+exports.always = always
+exports.constant = constant
+exports.unknown = exports.undefined_ = exports.optional = exports.nullable = exports.null_ = exports.mixed = exports.maybe = exports.hardcoded = void 0
 
-var _Decoder = require("../Decoder");
+var _Decoder = require('../Decoder')
 
-var _unions = require("./unions");
+var _unions = require('./unions')
 
-/**
- * Accepts and returns only the literal `null` value.
- */
 var null_ = (0, _Decoder.define)(function (blob, ok, err) {
-  return blob === null ? ok(blob) : err('Must be null');
-});
-/**
- * Accepts and returns only the literal `undefined` value.
- */
+  return blob === null ? ok(blob) : err('Must be null')
+})
 
-exports.null_ = null_;
+exports.null_ = null_
 var undefined_ = (0, _Decoder.define)(function (blob, ok, err) {
-  return blob === undefined ? ok(blob) : err('Must be undefined');
-});
-exports.undefined_ = undefined_;
+  return blob === undefined ? ok(blob) : err('Must be undefined')
+})
+exports.undefined_ = undefined_
 var undefined_or_null = (0, _Decoder.define)(function (blob, ok, err) {
-  return blob === undefined || blob === null ? ok(blob) : // Combine error message into a single line for readability
-  err('Must be undefined or null');
-});
+  return blob === undefined || blob === null ? ok(blob) : err('Must be undefined or null')
+})
 
 function _maybeish(emptyCase) {
-  function _inner(decoder
-  /* defaultValue */
-  ) {
-    var rv = (0, _unions.either)(emptyCase, decoder);
+  function _inner(decoder) {
+    var rv = (0, _unions.either)(emptyCase, decoder)
 
-    if ( // If a default value is provided...
-    arguments.length >= 2) {
-      // ...then return the default value
-      var _defaultValue = arguments[1];
+    if (arguments.length >= 2) {
+      var _defaultValue = arguments[1]
 
-      var _defaultValue2 = typeof _defaultValue === 'function' ? _defaultValue() : _defaultValue;
+      var _defaultValue2 = typeof _defaultValue === 'function' ? _defaultValue() : _defaultValue
 
       return rv.transform(function (value) {
-        return value != null ? value : _defaultValue2;
-      });
+        return value != null ? value : _defaultValue2
+      })
     } else {
-      // Otherwise the "normal" empty case
-      return rv;
+      return rv
     }
   }
 
-  return _inner;
+  return _inner
 }
-/**
- * Accepts whatever the given decoder accepts, or `null`.
- *
- * If a default value is explicitly provided, return that instead in the `null`
- * case.
- */
 
+var nullable = _maybeish(null_)
 
-var nullable = _maybeish(null_);
-/**
- * Accepts whatever the given decoder accepts, or `undefined`.
- *
- * If a default value is explicitly provided, return that instead in the
- * `undefined` case.
- */
+exports.nullable = nullable
 
+var optional = _maybeish(undefined_)
 
-exports.nullable = nullable;
+exports.optional = optional
 
-var optional = _maybeish(undefined_);
-/**
- * Accepts whatever the given decoder accepts, or `null`, or `undefined`.
- *
- * If a default value is explicitly provided, return that instead in the
- * `null`/`undefined` case.
- */
+var maybe = _maybeish(undefined_or_null)
 
-
-exports.optional = optional;
-
-var maybe = _maybeish(undefined_or_null);
-/**
- * Accepts only the given constant value.
- */
-
-
-exports.maybe = maybe;
+exports.maybe = maybe
 
 function constant(value) {
   return (0, _Decoder.define)(function (blob, ok, err) {
-    return blob === value ? ok(value) : err("Must be constant " + String(value));
-  });
+    return blob === value ? ok(value) : err('Must be constant ' + String(value))
+  })
 }
-/**
- * Accepts anything, completely ignores it, and always returns the provided
- * value instead.
- *
- * This is useful to manually add extra fields to object decoders.
- */
-
 
 function always(value) {
-  return (0, _Decoder.define)(typeof value === 'function' ? function (blob
-  /* ignored */
-  , ok, _) {
-    return (// $FlowFixMe[incompatible-use]
-      ok(value())
-    );
-  } : function (blob
-  /* ignored */
-  , ok, _) {
-    return ok(value);
-  });
+  return (0, _Decoder.define)(
+    typeof value === 'function'
+      ? function (
+          blob,
+
+          ok,
+          _
+        ) {
+          return ok(value())
+        }
+      : function (
+          blob,
+
+          ok,
+          _
+        ) {
+          return ok(value)
+        }
+  )
 }
-/**
- * Alias of always.
- */
-
 
-var hardcoded = always;
-/**
- * Accepts anything and returns it unchanged.
- *
- * Useful for situation in which you don't know or expect a specific type. Of
- * course, the downside is that you won't know the type of the value statically
- * and you'll have to further refine it yourself.
- */
+var hardcoded = always
 
-exports.hardcoded = hardcoded;
+exports.hardcoded = hardcoded
 var unknown = (0, _Decoder.define)(function (blob, ok, _) {
-  return ok(blob);
-});
-/**
- * Alias of unknown.
- */
-
-exports.unknown = unknown;
-var mixed = unknown;
-exports.mixed = mixed;
+  return ok(blob)
+})
+
+exports.unknown = unknown
+var mixed = unknown
+exports.mixed = mixed

package/lib/basics.mjs

@@ -1,120 +1,75 @@
-import { define } from '../Decoder.mjs';
-import { either } from './unions.mjs';
+import { define } from '../Decoder.mjs'
+import { either } from './unions.mjs'
 
-/**
- * Accepts and returns only the literal `null` value.
- */
 export var null_ = define(function (blob, ok, err) {
-  return blob === null ? ok(blob) : err('Must be null');
-});
-/**
- * Accepts and returns only the literal `undefined` value.
- */
+  return blob === null ? ok(blob) : err('Must be null')
+})
 
 export var undefined_ = define(function (blob, ok, err) {
-  return blob === undefined ? ok(blob) : err('Must be undefined');
-});
+  return blob === undefined ? ok(blob) : err('Must be undefined')
+})
 var undefined_or_null = define(function (blob, ok, err) {
-  return blob === undefined || blob === null ? ok(blob) : // Combine error message into a single line for readability
-  err('Must be undefined or null');
-});
+  return blob === undefined || blob === null ? ok(blob) : err('Must be undefined or null')
+})
 
 function _maybeish(emptyCase) {
-  function _inner(decoder
-  /* defaultValue */
-  ) {
-    var rv = either(emptyCase, decoder);
+  function _inner(decoder) {
+    var rv = either(emptyCase, decoder)
 
-    if ( // If a default value is provided...
-    arguments.length >= 2) {
-      // ...then return the default value
-      var _defaultValue = arguments[1];
+    if (arguments.length >= 2) {
+      var _defaultValue = arguments[1]
 
-      var _defaultValue2 = typeof _defaultValue === 'function' ? _defaultValue() : _defaultValue;
+      var _defaultValue2 = typeof _defaultValue === 'function' ? _defaultValue() : _defaultValue
 
       return rv.transform(function (value) {
-        return value != null ? value : _defaultValue2;
-      });
+        return value != null ? value : _defaultValue2
+      })
     } else {
-      // Otherwise the "normal" empty case
-      return rv;
+      return rv
     }
   }
 
-  return _inner;
+  return _inner
 }
-/**
- * Accepts whatever the given decoder accepts, or `null`.
- *
- * If a default value is explicitly provided, return that instead in the `null`
- * case.
- */
-
-
-export var nullable = _maybeish(null_);
-/**
- * Accepts whatever the given decoder accepts, or `undefined`.
- *
- * If a default value is explicitly provided, return that instead in the
- * `undefined` case.
- */
-
-export var optional = _maybeish(undefined_);
-/**
- * Accepts whatever the given decoder accepts, or `null`, or `undefined`.
- *
- * If a default value is explicitly provided, return that instead in the
- * `null`/`undefined` case.
- */
-
-export var maybe = _maybeish(undefined_or_null);
-/**
- * Accepts only the given constant value.
- */
+
+export var nullable = _maybeish(null_)
+
+export var optional = _maybeish(undefined_)
+
+export var maybe = _maybeish(undefined_or_null)
 
 export function constant(value) {
   return define(function (blob, ok, err) {
-    return blob === value ? ok(value) : err("Must be constant " + String(value));
-  });
+    return blob === value ? ok(value) : err('Must be constant ' + String(value))
+  })
 }
-/**
- * Accepts anything, completely ignores it, and always returns the provided
- * value instead.
- *
- * This is useful to manually add extra fields to object decoders.
- */
 
 export function always(value) {
-  return define(typeof value === 'function' ? function (blob
-  /* ignored */
-  , ok, _) {
-    return (// $FlowFixMe[incompatible-use]
-      ok(value())
-    );
-  } : function (blob
-  /* ignored */
-  , ok, _) {
-    return ok(value);
-  });
+  return define(
+    typeof value === 'function'
+      ? function (
+          blob,
+
+          ok,
+          _
+        ) {
+          return ok(value())
+        }
+      : function (
+          blob,
+
+          ok,
+          _
+        ) {
+          return ok(value)
+        }
+  )
 }
-/**
- * Alias of always.
- */
-
-export var hardcoded = always;
-/**
- * Accepts anything and returns it unchanged.
- *
- * Useful for situation in which you don't know or expect a specific type. Of
- * course, the downside is that you won't know the type of the value statically
- * and you'll have to further refine it yourself.
- */
+
+export var hardcoded = always
 
 export var unknown = define(function (blob, ok, _) {
-  return ok(blob);
-});
-/**
- * Alias of unknown.
- */
+  return ok(blob)
+})
 
-export var mixed = unknown;
+export var mixed = unknown

package/lib/booleans.js

@@ -1,35 +1,25 @@
-"use strict";
+'use strict'
 
-exports.__esModule = true;
-exports.truthy = exports.numericBoolean = exports["boolean"] = void 0;
+exports.__esModule = true
+exports.truthy = exports.numericBoolean = exports['boolean'] = void 0
 
-var _Decoder = require("../Decoder");
+var _Decoder = require('../Decoder')
 
-var _numbers = require("./numbers");
+var _numbers = require('./numbers')
 
-/**
- * Accepts and returns booleans.
- */
 var _boolean = (0, _Decoder.define)(function (blob, ok, err) {
-  return typeof blob === 'boolean' ? ok(blob) : err('Must be boolean');
-});
-/**
- * Accepts anything and will return its "truth" value. Will never reject.
- */
+  return typeof blob === 'boolean' ? ok(blob) : err('Must be boolean')
+})
 
-
-exports["boolean"] = _boolean;
+exports['boolean'] = _boolean
 var truthy = (0, _Decoder.define)(function (blob, ok, _) {
-  return ok(!!blob);
-});
-/**
- * Accepts numbers, but return their boolean representation.
- */
+  return ok(!!blob)
+})
 
-exports.truthy = truthy;
+exports.truthy = truthy
 
 var numericBoolean = _numbers.number.transform(function (n) {
-  return !!n;
-});
+  return !!n
+})
 
-exports.numericBoolean = numericBoolean;
+exports.numericBoolean = numericBoolean

package/lib/booleans.mjs

@@ -1,25 +1,15 @@
-import { define } from '../Decoder.mjs';
-import { number } from './numbers.mjs';
+import { define } from '../Decoder.mjs'
+import { number } from './numbers.mjs'
 
-/**
- * Accepts and returns booleans.
- */
 var _boolean = define(function (blob, ok, err) {
-  return typeof blob === 'boolean' ? ok(blob) : err('Must be boolean');
-});
-/**
- * Accepts anything and will return its "truth" value. Will never reject.
- */
+  return typeof blob === 'boolean' ? ok(blob) : err('Must be boolean')
+})
 
-
-export { _boolean as boolean };
+export { _boolean as boolean }
 export var truthy = define(function (blob, ok, _) {
-  return ok(!!blob);
-});
-/**
- * Accepts numbers, but return their boolean representation.
- */
+  return ok(!!blob)
+})
 
 export var numericBoolean = number.transform(function (n) {
-  return !!n;
-});
+  return !!n
+})

package/lib/dates.js

@@ -1,44 +1,28 @@
-"use strict";
+'use strict'
 
-exports.__esModule = true;
-exports.iso8601 = exports.date = void 0;
+exports.__esModule = true
+exports.iso8601 = exports.date = void 0
 
-var _utils = require("../_utils");
+var _utils = require('../_utils')
 
-var _Decoder = require("../Decoder");
+var _Decoder = require('../Decoder')
 
-var _strings = require("./strings");
-
-// 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})$/;
-/**
- * Accepts and returns `Date` instances.
- */
+var _strings = require('./strings')
+var iso8601_re = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:[.]\d+)?(?:Z|[+-]\d{2}:?\d{2})$/
 
 var date = (0, _Decoder.define)(function (blob, ok, err) {
-  var date = (0, _utils.asDate)(blob);
-  return date !== null ? ok(date) : err('Must be a Date');
-});
-/**
- * Accepts [ISO8601](https://en.wikipedia.org/wiki/ISO_8601)-formatted strings,
- * returns them as `Date` instances.
- *
- * This is very useful for working with dates in APIs: serialize them as
- * `.toISOString()` when sending, decode them with `iso8601` when receiving.
- */
-
-exports.date = date;
-var iso8601 = // Input itself needs to match the ISO8601 regex...
-(0, _strings.regex)(iso8601_re, 'Must be ISO8601 format').transform( // Make sure it is a _valid_ date
-function (value) {
-  var date = new Date(value);
+  var date = (0, _utils.asDate)(blob)
+  return date !== null ? ok(date) : err('Must be a Date')
+})
+
+exports.date = date
+var iso8601 = (0, _strings.regex)(iso8601_re, 'Must be ISO8601 format').transform(function (value) {
+  var date = new Date(value)
 
   if (isNaN(date.getTime())) {
-    throw new Error('Must be valid date/time value');
+    throw new Error('Must be valid date/time value')
   }
 
-  return date;
-});
-exports.iso8601 = iso8601;
+  return date
+})
+exports.iso8601 = iso8601