decoders 2.0.0 → 2.0.1

package/lib/json.js.flow

@@ -15,12 +15,12 @@ export type JSONObject = { [string]: JSONValue };
 export type JSONArray = Array<JSONValue>;
 
 /**
- * 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> = lazy(() => dict(json));
 
 /**
- * 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> = lazy(() => array(json));
 

package/lib/json.mjs

@@ -1,40 +1,18 @@
-import { array } from './arrays.mjs';
-import { boolean as _boolean } from './booleans.mjs';
-import { dict } from './objects.mjs';
-import { either } from './unions.mjs';
-import { lazy } from './utilities.mjs';
-import { null_ } from './basics.mjs';
-import { number } from './numbers.mjs';
-import { string } from './strings.mjs';
+import { array } from './arrays.mjs'
+import { boolean as _boolean } from './booleans.mjs'
+import { dict } from './objects.mjs'
+import { either } from './unions.mjs'
+import { lazy } from './utilities.mjs'
+import { null_ } from './basics.mjs'
+import { number } from './numbers.mjs'
+import { string } from './strings.mjs'
 
-/**
- * Like `json`, but will only decode when the JSON value is an object.
- */
 export var jsonObject = lazy(function () {
-  return dict(json);
-});
-/**
- * Like `json`, but will only decode when the JSON value is an array.
- */
+  return dict(json)
+})
 
 export var jsonArray = lazy(function () {
-  return 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[]
- * ```
- */
+  return array(json)
+})
 
-export var json = either(null_, string, number, _boolean, jsonObject, jsonArray).describe('Must be valid JSON value');
+export var json = either(null_, string, number, _boolean, jsonObject, jsonArray).describe('Must be valid JSON value')

package/lib/numbers.js

@@ -1,51 +1,31 @@
-"use strict";
+'use strict'
 
-exports.__esModule = true;
-exports.positiveNumber = exports.positiveInteger = exports.number = exports.integer = exports.anyNumber = void 0;
+exports.__esModule = true
+exports.positiveNumber = exports.positiveInteger = exports.number = exports.integer = exports.anyNumber = void 0
 
-var _Decoder = require("../Decoder");
+var _Decoder = require('../Decoder')
 
-/**
- * Accepts any valid ``number`` value.
- *
- * This also accepts special values like `NaN` and `Infinity`. Unless you
- * want to deliberately accept those, you'll likely want to use the
- * `number` decoder instead.
- */
 var anyNumber = (0, _Decoder.define)(function (blob, ok, err) {
-  return typeof blob === 'number' ? ok(blob) : err('Must be number');
-});
-/**
- * Accepts finite numbers (can be integer or float values). Values `NaN`,
- * or positive and negative `Infinity` will get rejected.
- */
+  return typeof blob === 'number' ? ok(blob) : err('Must be number')
+})
 
-exports.anyNumber = anyNumber;
+exports.anyNumber = anyNumber
 var number = anyNumber.refine(function (n) {
-  return Number.isFinite(n);
-}, 'Number must be finite');
-/**
- * Accepts only finite whole numbers.
- */
+  return Number.isFinite(n)
+}, 'Number must be finite')
 
-exports.number = number;
+exports.number = number
 var integer = number.refine(function (n) {
-  return Number.isInteger(n);
-}, 'Number must be an integer');
-/**
- * Accepts only positive finite numbers.
- */
+  return Number.isInteger(n)
+}, 'Number must be an integer')
 
-exports.integer = integer;
+exports.integer = integer
 var positiveNumber = number.refine(function (n) {
-  return n >= 0;
-}, 'Number must be positive');
-/**
- * Accepts only positive finite whole numbers.
- */
+  return n >= 0
+}, 'Number must be positive')
 
-exports.positiveNumber = positiveNumber;
+exports.positiveNumber = positiveNumber
 var positiveInteger = integer.refine(function (n) {
-  return n >= 0;
-}, 'Number must be positive');
-exports.positiveInteger = positiveInteger;
+  return n >= 0
+}, 'Number must be positive')
+exports.positiveInteger = positiveInteger

package/lib/numbers.mjs

@@ -1,41 +1,21 @@
-import { define } from '../Decoder.mjs';
+import { define } from '../Decoder.mjs'
 
-/**
- * Accepts any valid ``number`` value.
- *
- * This also accepts special values like `NaN` and `Infinity`. Unless you
- * want to deliberately accept those, you'll likely want to use the
- * `number` decoder instead.
- */
 export var anyNumber = define(function (blob, ok, err) {
-  return typeof blob === 'number' ? ok(blob) : err('Must be number');
-});
-/**
- * Accepts finite numbers (can be integer or float values). Values `NaN`,
- * or positive and negative `Infinity` will get rejected.
- */
+  return typeof blob === 'number' ? ok(blob) : err('Must be number')
+})
 
 export var number = anyNumber.refine(function (n) {
-  return Number.isFinite(n);
-}, 'Number must be finite');
-/**
- * Accepts only finite whole numbers.
- */
+  return Number.isFinite(n)
+}, 'Number must be finite')
 
 export var integer = number.refine(function (n) {
-  return Number.isInteger(n);
-}, 'Number must be an integer');
-/**
- * Accepts only positive finite numbers.
- */
+  return Number.isInteger(n)
+}, 'Number must be an integer')
 
 export var positiveNumber = number.refine(function (n) {
-  return n >= 0;
-}, 'Number must be positive');
-/**
- * Accepts only positive finite whole numbers.
- */
+  return n >= 0
+}, 'Number must be positive')
 
 export var positiveInteger = integer.refine(function (n) {
-  return n >= 0;
-}, 'Number must be positive');
+  return n >= 0
+}, 'Number must be positive')

package/lib/objects.d.ts

@@ -11,14 +11,14 @@ export type ObjectDecoderType<T> = AllowImplicit<{
  * Accepts any "plain old JavaScript object", but doesn't validate its keys or
  * values further.
  */
-export const pojo: Decoder<{ [key: string]: unknown }>;
+export const pojo: Decoder<Record<string, unknown>>;
 
 /**
  * Accepts objects with fields matching the given decoders. Extra fields that
  * exist on the input object are ignored and will not be returned.
  */
 export function object(decodersByKey: Record<any, never>): Decoder<Record<string, never>>;
-export function object<O extends { [key: string]: Decoder<any> }>(
+export function object<O extends Record<string, Decoder<any>>>(
     decodersByKey: O,
 ): Decoder<{ [K in keyof ObjectDecoderType<O>]: ObjectDecoderType<O>[K] }>;
 //         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -34,7 +34,7 @@ export function object<O extends { [key: string]: Decoder<any> }>(
  * not specified explicitly.
  */
 export function exact(decodersByKey: Record<any, never>): Decoder<Record<string, never>>;
-export function exact<O extends { [key: string]: Decoder<any> }>(
+export function exact<O extends Record<string, Decoder<any>>>(
     decodersByKey: O,
 ): Decoder<{ [K in keyof ObjectDecoderType<O>]: ObjectDecoderType<O>[K] }>;
 //         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -46,18 +46,19 @@ export function exact<O extends { [key: string]: Decoder<any> }>(
  */
 export function inexact(
     decodersByKey: Record<any, never>,
-): Decoder<{ [extra: string]: unknown }>;
-export function inexact<O extends { [key: string]: Decoder<any> }>(
+): Decoder<Record<string, unknown>>;
+export function inexact<O extends Record<string, Decoder<any>>>(
     decodersByKey: O,
 ): Decoder<
-    { [K in keyof ObjectDecoderType<O>]: ObjectDecoderType<O>[K] } & {
-        [extra: string]: unknown;
-    }
+    { [K in keyof ObjectDecoderType<O>]: ObjectDecoderType<O>[K] } & Record<
+        string,
+        unknown
+    >
 >;
 
 /**
  * Accepts objects where all values match the given decoder, and returns the
- * result as a `{ [string]: T }`.
+ * result as a `Record<string, T>`.
  *
  * The main difference between `object()` and `dict()` is that you'd typically
  * use `object()` if this is a record-like object, where all field names are
@@ -65,7 +66,7 @@ export function inexact<O extends { [key: string]: Decoder<any> }>(
  * typically dynamic and the values homogeneous, like in a dictionary,
  * a lookup table, or a cache.
  */
-export function dict<T>(decoder: Decoder<T>): Decoder<{ [key: string]: T }>;
+export function dict<T>(decoder: Decoder<T>): Decoder<Record<string, T>>;
 
 /**
  * Similar to `dict()`, but returns the result as a `Map<string, T>` (an [ES6

package/lib/objects.js

@@ -1,240 +1,161 @@
-"use strict";
+'use strict'
 
-exports.__esModule = true;
-exports.dict = dict;
-exports.exact = exact;
-exports.inexact = inexact;
-exports.mapping = mapping;
-exports.object = object;
-exports.pojo = void 0;
+exports.__esModule = true
+exports.dict = dict
+exports.exact = exact
+exports.inexact = inexact
+exports.mapping = mapping
+exports.object = object
+exports.pojo = void 0
 
-var _annotate = require("../annotate");
+var _annotate = require('../annotate')
 
-var _Decoder = require("../Decoder");
-
-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); }
-
-function subtract(xs, ys) {
-  var result = new Set();
-  xs.forEach(function (x) {
-    if (!ys.has(x)) {
-      result.add(x);
-    }
-  });
-  return result;
-}
-/**
- * Accepts any "plain old JavaScript object", but doesn't validate its keys or
- * values further.
- */
+var _Decoder = require('../Decoder')
 
+var _utils = require('../_utils')
 
 var pojo = (0, _Decoder.define)(function (blob, ok, err) {
-  return blob !== null && blob !== undefined && typeof blob === 'object' && // This still seems to be the only reliable way to determine whether
-  // something is a pojo... ¯\_(ツ)_/¯
-  // $FlowFixMe[method-unbinding]
-  Object.prototype.toString.call(blob) === '[object Object]' ? 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)) : err('Must be an object');
-});
-/**
- * Accepts objects with fields matching the given decoders. Extra fields that
- * exist on the input object are ignored and will not be returned.
- */
-
-exports.pojo = pojo;
+  return blob !== null && blob !== undefined && typeof blob === 'object' && Object.prototype.toString.call(blob) === '[object Object]' ? ok(blob) : err('Must be an object')
+})
+
+exports.pojo = pojo
 
 function object(decodersByKey) {
-  // Compute this set at decoder definition time
-  var knownKeys = new Set(Object.keys(decodersByKey));
+  var knownKeys = new Set(Object.keys(decodersByKey))
   return pojo.then(function (plainObj, ok, err) {
-    var actualKeys = new Set(Object.keys(plainObj)); // At this point, "missingKeys" 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 missingKeys = subtract(knownKeys, actualKeys);
-    var record = {};
-    var errors = null;
+    var actualKeys = new Set(Object.keys(plainObj))
+
+    var missingKeys = (0, _utils.subtract)(knownKeys, actualKeys)
+    var record = {}
+    var errors = null
     Object.keys(decodersByKey).forEach(function (key) {
-      var decoder = decodersByKey[key];
-      var rawValue = plainObj[key];
-      var result = decoder.decode(rawValue);
+      var decoder = decodersByKey[key]
+      var rawValue = plainObj[key]
+      var result = decoder.decode(rawValue)
 
       if (result.ok) {
-        var value = result.value;
+        var value = result.value
 
         if (value !== undefined) {
-          record[key] = value;
-        } // If this succeeded, remove the key from the missing keys
-        // tracker
-
+          record[key] = value
+        }
 
-        missingKeys["delete"](key);
+        missingKeys['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.
+        var ann = result.error
 
         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).
-          missingKeys.add(key);
+          missingKeys.add(key)
         } else {
           if (errors === null) {
-            errors = {};
+            errors = {}
           }
 
-          errors[key] = ann;
+          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 || missingKeys.size > 0) {
-      var objAnn = (0, _annotate.annotateObject)(plainObj);
+      var objAnn = (0, _annotate.annotateObject)(plainObj)
 
       if (errors) {
-        objAnn = (0, _annotate.merge)(objAnn, errors);
+        objAnn = (0, _annotate.merge)(objAnn, errors)
       }
 
       if (missingKeys.size > 0) {
-        var errMsg = Array.from(missingKeys).map(function (key) {
-          return "\"" + key + "\"";
-        }).join(', ');
-        var pluralized = missingKeys.size > 1 ? 'keys' : 'key';
-        objAnn = (0, _annotate.updateText)(objAnn, "Missing " + pluralized + ": " + errMsg);
+        var errMsg = Array.from(missingKeys)
+          .map(function (key) {
+            return '"' + key + '"'
+          })
+          .join(', ')
+        var pluralized = missingKeys.size > 1 ? 'keys' : 'key'
+        objAnn = (0, _annotate.updateText)(objAnn, 'Missing ' + pluralized + ': ' + errMsg)
       }
 
-      return err(objAnn);
+      return err(objAnn)
     }
 
-    return ok(record);
-  });
+    return ok(record)
+  })
 }
-/**
- * Like `object()`, but will reject inputs that contain extra fields that are
- * not specified explicitly.
- */
-
 
 function exact(decodersByKey) {
-  // Compute this set at decoder definition time
-  var allowedKeys = new Set(Object.keys(decodersByKey)); // Check the inputted object for any unexpected extra keys
+  var allowedKeys = new Set(Object.keys(decodersByKey))
 
   var checked = pojo.reject(function (plainObj) {
-    var actualKeys = new Set(Object.keys(plainObj));
-    var extraKeys = subtract(actualKeys, allowedKeys);
-    return extraKeys.size > 0 ? "Unexpected extra keys: " + Array.from(extraKeys).join(', ') : // Don't reject
-    null;
-  }); // 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.
-
-  return checked.then(object(decodersByKey).decode);
-}
-/**
- * Like `object()`, but will pass through any extra fields on the input object
- * unvalidated that will thus be of `unknown` type statically.
- */
+    var actualKeys = new Set(Object.keys(plainObj))
+    var extraKeys = (0, _utils.subtract)(actualKeys, allowedKeys)
+    return extraKeys.size > 0 ? 'Unexpected extra keys: ' + Array.from(extraKeys).join(', ') : null
+  })
 
+  return checked.then(object(decodersByKey).decode)
+}
 
 function inexact(decodersByKey) {
   return pojo.then(function (plainObj) {
-    var allkeys = new Set(Object.keys(plainObj));
+    var allkeys = new Set(Object.keys(plainObj))
     var decoder = object(decodersByKey).transform(function (safepart) {
-      var safekeys = new Set(Object.keys(decodersByKey)); // To account for hard-coded keys that aren't part of the input
+      var safekeys = new Set(Object.keys(decodersByKey))
 
       safekeys.forEach(function (k) {
-        return allkeys.add(k);
-      });
-      var rv = {};
+        return allkeys.add(k)
+      })
+      var rv = {}
       allkeys.forEach(function (k) {
         if (safekeys.has(k)) {
-          var value = safepart[k];
+          var value = safepart[k]
 
           if (value !== undefined) {
-            rv[k] = value;
+            rv[k] = value
           }
         } else {
-          rv[k] = plainObj[k];
+          rv[k] = plainObj[k]
         }
-      });
-      return rv;
-    });
-    return decoder.decode(plainObj);
-  });
+      })
+      return rv
+    })
+    return decoder.decode(plainObj)
+  })
 }
-/**
- * Accepts objects where all values match the given decoder, and returns the
- * result as a `{ [string]: T }`.
- *
- * The main difference between `object()` and `dict()` is that you'd typically
- * use `object()` if this is a record-like object, where all field names are
- * known and the values are heterogeneous. Whereas with `dict()` the keys are
- * typically dynamic and the values homogeneous, like in a dictionary,
- * a lookup table, or a cache.
- */
-
 
 function dict(decoder) {
   return pojo.then(function (plainObj, ok, err) {
-    var rv = {};
-    var errors = null;
+    var rv = {}
+    var errors = null
     Object.keys(plainObj).forEach(function (key) {
-      var value = plainObj[key];
-      var result = decoder.decode(value);
+      var value = plainObj[key]
+      var result = decoder.decode(value)
 
       if (result.ok) {
         if (errors === null) {
-          rv[key] = result.value;
+          rv[key] = result.value
         }
       } else {
-        rv = {}; // Clear the success value so it can get garbage collected early
+        rv = {}
 
         if (errors === null) {
-          errors = {};
+          errors = {}
         }
 
-        errors[key] = result.error;
+        errors[key] = result.error
       }
-    });
+    })
 
     if (errors !== null) {
-      return err((0, _annotate.merge)((0, _annotate.annotateObject)(plainObj), errors));
+      return err((0, _annotate.merge)((0, _annotate.annotateObject)(plainObj), errors))
     } else {
-      return ok(rv);
+      return ok(rv)
     }
-  });
+  })
 }
-/**
- * Similar to `dict()`, but returns the result as a `Map<string, T>` (an [ES6
- * Map](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map))
- * instead.
- */
-
 
 function mapping(decoder) {
   return dict(decoder).transform(function (obj) {
-    return new Map( // This is effectively Object.entries(obj), but in a way that Flow
-    // will know the types are okay
-    Object.keys(obj).map(function (key) {
-      return [key, obj[key]];
-    }));
-  });
-}
+    return new Map(
+      Object.keys(obj).map(function (key) {
+        return [key, obj[key]]
+      })
+    )
+  })
+}

package/lib/objects.js.flow

@@ -2,20 +2,11 @@
 
 import { annotateObject, merge, updateText } from '../annotate';
 import { define } from '../Decoder';
+import { subtract } from '../_utils';
 import type { Annotation } from '../annotate';
 import type { _Any as AnyDecoder } from '../_utils';
 import type { Decoder, DecodeResult } from '../Decoder';
 
-function subtract(xs: Set<string>, ys: Set<string>): Set<string> {
-    const result = new Set();
-    xs.forEach((x) => {
-        if (!ys.has(x)) {
-            result.add(x);
-        }
-    });
-    return result;
-}
-
 /**
  * Accepts any "plain old JavaScript object", but doesn't validate its keys or
  * values further.
@@ -43,7 +34,8 @@ export const pojo: Decoder<{| [string]: mixed |}> = define((blob, ok, err) =>
               // 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)
-              { ...blob },
+              // $FlowFixMe[incompatible-variance]
+              blob,
           )
         : err('Must be an object'),
 );
@@ -192,7 +184,7 @@ export function inexact<O: { +[field: string]: AnyDecoder }>(
 
 /**
  * Accepts objects where all values match the given decoder, and returns the
- * result as a `{ [string]: T }`.
+ * result as a `Record<string, T>`.
  *
  * The main difference between `object()` and `dict()` is that you'd typically
  * use `object()` if this is a record-like object, where all field names are