decoders 2.0.0 → 2.0.1

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

package/lib/dates.mjs

@@ -1,34 +1,19 @@
-import { asDate } from '../_utils.mjs';
-import { define } from '../Decoder.mjs';
-import { regex } from './strings.mjs';
-// 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.
- */
+import { asDate } from '../_utils.mjs'
+import { define } from '../Decoder.mjs'
+import { regex } from './strings.mjs'
+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 = define(function (blob, ok, err) {
-  var date = 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.
- */
+  var date = asDate(blob)
+  return date !== null ? ok(date) : err('Must be a Date')
+})
 
-export var iso8601 = // Input itself needs to match the ISO8601 regex...
-regex(iso8601_re, 'Must be ISO8601 format').transform( // Make sure it is a _valid_ date
-function (value) {
-  var date = new Date(value);
+export var iso8601 = 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;
-});
+  return date
+})

package/lib/json.d.ts

@@ -2,7 +2,7 @@ import { Decoder } from '../Decoder';
 
 export type JSONValue = null | string | number | boolean | JSONObject | JSONArray;
 export interface JSONObject {
-    [key: string]: JSONValue;
+    [key: string]: JSONValue | undefined;
 }
 export type JSONArray = JSONValue[];
 
@@ -25,11 +25,11 @@ export type JSONArray = JSONValue[];
 export const json: Decoder<JSONValue>;
 
 /**
- * Like `json`, but will only decode when the JSON value is an array.
+ * Accepts arrays that contain only valid JSON values.
  */
 export const jsonArray: Decoder<JSONArray>;
 
 /**
- * Like `json`, but will only decode when the JSON value is an object.
+ * Accepts objects that contain only valid JSON values.
  */
 export const jsonObject: Decoder<JSONObject>;

package/lib/json.js

@@ -1,55 +1,33 @@
-"use strict";
+'use strict'
 
-exports.__esModule = true;
-exports.jsonObject = exports.jsonArray = exports.json = void 0;
+exports.__esModule = true
+exports.jsonObject = exports.jsonArray = exports.json = void 0
 
-var _arrays = require("./arrays");
+var _arrays = require('./arrays')
 
-var _booleans = require("./booleans");
+var _booleans = require('./booleans')
 
-var _objects = require("./objects");
+var _objects = require('./objects')
 
-var _unions = require("./unions");
+var _unions = require('./unions')
 
-var _utilities = require("./utilities");
+var _utilities = require('./utilities')
 
-var _basics = require("./basics");
+var _basics = require('./basics')
 
-var _numbers = require("./numbers");
+var _numbers = require('./numbers')
 
-var _strings = require("./strings");
+var _strings = require('./strings')
 
-/**
- * Like `json`, but will only decode when the JSON value is an object.
- */
 var jsonObject = (0, _utilities.lazy)(function () {
-  return (0, _objects.dict)(json);
-});
-/**
- * Like `json`, but will only decode when the JSON value is an array.
- */
+  return (0, _objects.dict)(json)
+})
 
-exports.jsonObject = jsonObject;
+exports.jsonObject = jsonObject
 var jsonArray = (0, _utilities.lazy)(function () {
-  return (0, _arrays.array)(json);
-});
-/**
- * Accepts any value that's a valid JSON value.
- *
- * In other words: any value returned by `JSON.parse()` should decode without
- * failure.
- *
- * ```typescript
- * type JSONValue =
- *     | null
- *     | string
- *     | number
- *     | boolean
- *     | { [string]: JSONValue }
- *     | JSONValue[]
- * ```
- */
-
-exports.jsonArray = jsonArray;
-var json = (0, _unions.either)(_basics.null_, _strings.string, _numbers.number, _booleans["boolean"], jsonObject, jsonArray).describe('Must be valid JSON value');
-exports.json = json;
+  return (0, _arrays.array)(json)
+})
+
+exports.jsonArray = jsonArray
+var json = (0, _unions.either)(_basics.null_, _strings.string, _numbers.number, _booleans['boolean'], jsonObject, jsonArray).describe('Must be valid JSON value')
+exports.json = json