decoders 2.0.0 → 2.0.2

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

package/lib/objects.mjs

@@ -1,223 +1,147 @@
-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 { annotateObject, merge, updateText } from '../annotate.mjs';
-import { define } from '../Decoder.mjs';
-
-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.
- */
-
+import { annotateObject, merge, updateText } from '../annotate.mjs'
+import { define } from '../Decoder.mjs'
+import { subtract } from '../_utils.mjs'
 
 export var pojo = 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.
- */
+  return blob !== null && blob !== undefined && typeof blob === 'object' && Object.prototype.toString.call(blob) === '[object Object]' ? ok(blob) : err('Must be an object')
+})
 
 export 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 = 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 = annotateObject(plainObj);
+      var objAnn = annotateObject(plainObj)
 
       if (errors) {
-        objAnn = merge(objAnn, errors);
+        objAnn = 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 = updateText(objAnn, "Missing " + pluralized + ": " + errMsg);
+        var errMsg = Array.from(missingKeys)
+          .map(function (key) {
+            return '"' + key + '"'
+          })
+          .join(', ')
+        var pluralized = missingKeys.size > 1 ? 'keys' : 'key'
+        objAnn = 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.
- */
 
 export 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);
+    var actualKeys = new Set(Object.keys(plainObj))
+    var extraKeys = subtract(actualKeys, allowedKeys)
+    return extraKeys.size > 0 ? 'Unexpected extra keys: ' + Array.from(extraKeys).join(', ') : null
+  })
+
+  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.
- */
 
 export 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.
- */
 
 export 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(merge(annotateObject(plainObj), errors));
+      return err(merge(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.
- */
 
 export 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]]
+      })
+    )
+  })
+}