decoders 1.25.4 → 2.0.0-beta1

package/{json.js → cjs/stdlib/json.js}

@@ -1,21 +1,19 @@
 "use strict";
 
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
+exports.__esModule = true;
 exports.jsonObject = exports.jsonArray = exports.json = void 0;
 
 var _array = require("./array");
 
 var _boolean2 = require("./boolean");
 
-var _constants = require("./constants");
+var _mapping = require("./mapping");
 
 var _either = require("./either");
 
 var _lazy = require("./lazy");
 
-var _mapping = require("./mapping");
+var _constants = require("./constants");
 
 var _number = require("./number");
 

package/{json.js.flow → cjs/stdlib/json.js.flow}

@@ -2,13 +2,13 @@
 
 import { array } from './array';
 import { boolean } from './boolean';
-import { null_ } from './constants';
+import { dict } from './mapping';
 import { either6 } from './either';
 import { lazy } from './lazy';
-import { dict } from './mapping';
+import { null_ } from './constants';
 import { number } from './number';
 import { string } from './string';
-import type { Decoder } from './types';
+import type { Decoder } from '../_types';
 
 export type JSONValue = null | string | number | boolean | JSONObject | JSONArray;
 export type JSONObject = { [string]: JSONValue };
@@ -24,5 +24,5 @@ export const json: Decoder<JSONValue> = either6(
     number,
     boolean,
     jsonObject,
-    jsonArray
+    jsonArray,
 );

package/{lazy.js → cjs/stdlib/lazy.js}

@@ -1,8 +1,6 @@
 "use strict";
 
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
+exports.__esModule = true;
 exports.lazy = lazy;
 
 /**

package/{lazy.js.flow → cjs/stdlib/lazy.js.flow}

@@ -1,6 +1,6 @@
 // @flow strict
 
-import type { Decoder } from './types';
+import type { Decoder } from '../_types';
 
 /**
  * Given an function returning a Decoder, will use that decoder to decode the

package/cjs/stdlib/mapping.js

@@ -0,0 +1,67 @@
+"use strict";
+
+exports.__esModule = true;
+exports.dict = dict;
+exports.mapping = mapping;
+
+var Result = _interopRequireWildcard(require("../result"));
+
+var _annotate = require("../annotate");
+
+var _composition = require("./composition");
+
+var _object = require("./object");
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+/**
+ * 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)
+ *
+ */
+function mapping(decoder) {
+  return (0, _composition.compose)(_object.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((0, _annotate.merge)((0, _annotate.annotateObject)(blob), errors));
+    } else {
+      return Result.ok(new Map(tuples));
+    }
+  });
+}
+/**
+ * Like mapping(), but returns an object rather than a Map instance.
+ */
+
+
+function dict(decoder) {
+  return (0, _composition.map)(mapping(decoder), function (m) {
+    return Object.fromEntries(m);
+  });
+}

package/cjs/stdlib/mapping.js.flow

@@ -0,0 +1,54 @@
+// @flow strict
+
+import * as Result from '../result';
+import { annotateObject } from '../annotate';
+import { compose, map } from './composition';
+import { merge } from '../annotate';
+import { pojo } from './object';
+import type { Annotation } from '../annotate';
+import type { Decoder } from '../_types';
+
+/**
+ * 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<T>(decoder: Decoder<T>): Decoder<Map<string, T>> {
+    return compose(pojo, (blob: { +[key: string]: mixed }) => {
+        let tuples: Array<[string, T]> = [];
+        let errors: { [key: string]: Annotation } | null = null;
+
+        Object.keys(blob).forEach((key: string) => {
+            const value = blob[key];
+            const 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<T>(decoder: Decoder<T>): Decoder<{ [string]: T }> {
+    return map(mapping(decoder), (m) => Object.fromEntries(m));
+}

package/cjs/stdlib/number.js

@@ -0,0 +1,40 @@
+"use strict";
+
+exports.__esModule = true;
+exports.positiveNumber = exports.positiveInteger = exports.number = exports.integer = void 0;
+
+var Result = _interopRequireWildcard(require("../result"));
+
+var _annotate = require("../annotate");
+
+var _composition = require("./composition");
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+var anyNumber = function anyNumber(blob) {
+  return typeof blob === 'number' && !Number.isNaN(blob) ? Result.ok(blob) : Result.err((0, _annotate.annotate)(blob, 'Must be number'));
+};
+
+var isInteger = function isInteger(n) {
+  return Number.isInteger(n);
+};
+
+var isFinite = function isFinite(n) {
+  return Number.isFinite(n);
+};
+
+var number = (0, _composition.compose)(anyNumber, (0, _composition.predicate)(isFinite, 'Number must be finite'));
+exports.number = number;
+var positiveNumber = (0, _composition.compose)(number, (0, _composition.predicate)(function (n) {
+  return n >= 0;
+}, 'Number must be positive')); // Integers
+
+exports.positiveNumber = positiveNumber;
+var integer = (0, _composition.compose)(number, (0, _composition.predicate)(isInteger, 'Number must be an integer'));
+exports.integer = integer;
+var positiveInteger = (0, _composition.compose)(integer, (0, _composition.predicate)(function (n) {
+  return n >= 0;
+}, 'Number must be positive'));
+exports.positiveInteger = positiveInteger;

package/{number.js.flow → cjs/stdlib/number.js.flow}

@@ -1,15 +1,14 @@
 // @flow strict
 
-import { annotate } from 'debrief';
-import { Err, Ok } from 'lemons/Result';
-
-import type { Decoder } from './types';
-import { compose, predicate } from './utils';
+import * as Result from '../result';
+import { annotate } from '../annotate';
+import { compose, predicate } from './composition';
+import type { Decoder } from '../_types';
 
 const anyNumber: Decoder<number> = (blob: mixed) => {
     return typeof blob === 'number' && !Number.isNaN(blob)
-        ? Ok(blob)
-        : Err(annotate(blob, 'Must be number'));
+        ? Result.ok(blob)
+        : Result.err(annotate(blob, 'Must be number'));
 };
 
 const isInteger = (n: number) => Number.isInteger(n);
@@ -17,19 +16,19 @@ const isFinite = (n: number) => Number.isFinite(n);
 
 export const number: Decoder<number> = compose(
     anyNumber,
-    predicate(isFinite, 'Number must be finite')
+    predicate(isFinite, 'Number must be finite'),
 );
 export const positiveNumber: Decoder<number> = compose(
     number,
-    predicate((n) => n >= 0, 'Number must be positive')
+    predicate((n) => n >= 0, 'Number must be positive'),
 );
 
 // Integers
 export const integer: Decoder<number> = compose(
     number,
-    predicate(isInteger, 'Number must be an integer')
+    predicate(isInteger, 'Number must be an integer'),
 );
 export const positiveInteger: Decoder<number> = compose(
     integer,
-    predicate((n) => n >= 0, 'Number must be positive')
+    predicate((n) => n >= 0, 'Number must be positive'),
 );

package/cjs/stdlib/object.js

@@ -0,0 +1,194 @@
+"use strict";
+
+exports.__esModule = true;
+exports.exact = exact;
+exports.inexact = inexact;
+exports.object = object;
+exports.pojo = void 0;
+
+var Result = _interopRequireWildcard(require("../result"));
+
+var _annotate = require("../annotate");
+
+var _composition = require("./composition");
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+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 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;
+}
+
+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((0, _annotate.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<...>.
+ */
+
+
+exports.pojo = pojo;
+
+function object(mapping) {
+  var known = new Set(Object.keys(mapping));
+  return (0, _composition.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 = (0, _annotate.annotateObject)(blob);
+
+      if (errors) {
+        objAnn = (0, _annotate.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 = (0, _annotate.updateText)(objAnn, "Missing " + pluralized + ": " + errMsg);
+      }
+
+      return Result.err(objAnn);
+    }
+
+    return Result.ok(record);
+  });
+}
+
+function exact(mapping) {
+  // Check the inputted object for any superfluous keys
+  var allowed = new Set(Object.keys(mapping));
+  var checked = (0, _composition.compose)(pojo, function (blob) {
+    var actual = new Set(Object.keys(blob));
+    var superfluous = subtract(actual, allowed);
+
+    if (superfluous.size > 0) {
+      return Result.err((0, _annotate.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 (0, _composition.compose)(checked, decoder);
+}
+
+function inexact(mapping) {
+  return (0, _composition.compose)(pojo, function (blob) {
+    var allkeys = new Set(Object.keys(blob));
+    var decoder = (0, _composition.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);
+  });
+}