decoders 2.0.0-beta8 → 2.0.1

package/core/object.mjs

@@ -1,175 +0,0 @@
-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 { annotate, annotateObject, merge, updateText } from '../annotate.mjs';
-import { compose, map } from './composition.mjs';
-import { err, ok } from '../result.mjs';
-
-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;
-}
-
-export var pojo = function pojo(blob) {
-  return isPojo(blob) ? 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(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<...>.
- */
-
-export function object(mapping) {
-  var known = new Set(Object.keys(mapping));
-  return 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 = annotateObject(blob);
-
-      if (errors) {
-        objAnn = 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 = updateText(objAnn, "Missing " + pluralized + ": " + errMsg);
-      }
-
-      return err(objAnn);
-    }
-
-    return ok(record);
-  });
-}
-export function exact(mapping) {
-  // Check the inputted object for any superfluous keys
-  var allowed = new Set(Object.keys(mapping));
-  var checked = compose(pojo, function (blob) {
-    var actual = new Set(Object.keys(blob));
-    var superfluous = subtract(actual, allowed);
-
-    if (superfluous.size > 0) {
-      return err(annotate(blob, "Superfluous keys: " + Array.from(superfluous).join(', ')));
-    }
-
-    return 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 compose(checked, decoder);
-}
-export function inexact(mapping) {
-  return compose(pojo, function (blob) {
-    var allkeys = new Set(Object.keys(blob));
-    var decoder = 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);
-  });
-}

package/core/optional.d.ts

@@ -1,5 +0,0 @@
-import { Decoder } from '../_types';
-
-export function optional<T>(decoder: Decoder<T>): Decoder<T | undefined>;
-export function nullable<T>(decoder: Decoder<T>): Decoder<T | null>;
-export function maybe<T>(decoder: Decoder<T>): Decoder<T | null | undefined>;

package/core/optional.js

@@ -1,50 +0,0 @@
-"use strict";
-
-exports.__esModule = true;
-exports.maybe = maybe;
-exports.nullable = nullable;
-exports.optional = optional;
-
-var _annotate = require("../annotate");
-
-var _either = require("./either");
-
-var _result = require("../result");
-
-var _constants = require("./constants");
-
-/**
- * Builds a Decoder that returns Ok for either `undefined` or `T` values,
- * given a Decoder for `T`.  Err otherwise.
- */
-function optional(decoder) {
-  return (0, _either.either)(_constants.undefined_, decoder);
-}
-/**
- * Builds a Decoder that returns Ok for either `null` or `T` values,
- * given a Decoder for `T`.  Err otherwise.
- */
-
-
-function nullable(decoder) {
-  return (0, _either.either)(_constants.null_, decoder);
-}
-/**
- * Decoder that only returns Ok for `null` or `undefined` inputs.
- * This is effectively equivalent to either(null_, undefined_), but combines
- * their error message output into a single line for convenience.
- */
-
-
-var undefined_or_null = function undefined_or_null(blob) {
-  return blob === undefined || blob === null ? (0, _result.ok)(blob) : // Combine error message into a single line
-  (0, _result.err)((0, _annotate.annotate)(blob, 'Must be undefined or null'));
-};
-/**
- * Decoder that only returns Ok for `null` or `undefined` inputs.
- */
-
-
-function maybe(decoder) {
-  return (0, _either.either)(undefined_or_null, decoder);
-}

package/core/optional.js.flow

@@ -1,41 +0,0 @@
-// @flow strict
-
-import { annotate } from '../annotate';
-import { either } from './either';
-import { err, ok } from '../result';
-import { null_, undefined_ } from './constants';
-import type { Decoder } from '../_types';
-
-/**
- * Builds a Decoder that returns Ok for either `undefined` or `T` values,
- * given a Decoder for `T`.  Err otherwise.
- */
-export function optional<T>(decoder: Decoder<T>): Decoder<void | T> {
-    return either(undefined_, decoder);
-}
-
-/**
- * Builds a Decoder that returns Ok for either `null` or `T` values,
- * given a Decoder for `T`.  Err otherwise.
- */
-export function nullable<T>(decoder: Decoder<T>): Decoder<null | T> {
-    return either(null_, decoder);
-}
-
-/**
- * Decoder that only returns Ok for `null` or `undefined` inputs.
- * This is effectively equivalent to either(null_, undefined_), but combines
- * their error message output into a single line for convenience.
- */
-const undefined_or_null: Decoder<null | void> = (blob: mixed) =>
-    blob === undefined || blob === null
-        ? ok(blob)
-        : // Combine error message into a single line
-          err(annotate(blob, 'Must be undefined or null'));
-
-/**
- * Decoder that only returns Ok for `null` or `undefined` inputs.
- */
-export function maybe<T>(decoder: Decoder<T>): Decoder<?T> {
-    return either(undefined_or_null, decoder);
-}

package/core/optional.mjs

@@ -1,38 +0,0 @@
-import { annotate } from '../annotate.mjs';
-import { either } from './either.mjs';
-import { err, ok } from '../result.mjs';
-import { null_, undefined_ } from './constants.mjs';
-
-/**
- * Builds a Decoder that returns Ok for either `undefined` or `T` values,
- * given a Decoder for `T`.  Err otherwise.
- */
-export function optional(decoder) {
-  return either(undefined_, decoder);
-}
-/**
- * Builds a Decoder that returns Ok for either `null` or `T` values,
- * given a Decoder for `T`.  Err otherwise.
- */
-
-export function nullable(decoder) {
-  return either(null_, decoder);
-}
-/**
- * Decoder that only returns Ok for `null` or `undefined` inputs.
- * This is effectively equivalent to either(null_, undefined_), but combines
- * their error message output into a single line for convenience.
- */
-
-var undefined_or_null = function undefined_or_null(blob) {
-  return blob === undefined || blob === null ? ok(blob) : // Combine error message into a single line
-  err(annotate(blob, 'Must be undefined or null'));
-};
-/**
- * Decoder that only returns Ok for `null` or `undefined` inputs.
- */
-
-
-export function maybe(decoder) {
-  return either(undefined_or_null, decoder);
-}

package/core/string.d.ts

@@ -1,10 +0,0 @@
-/// <reference lib="dom" />
-
-import { Decoder } from '../_types';
-
-export const string: Decoder<string>;
-export const nonEmptyString: Decoder<string>;
-export function regex(regex: RegExp, msg: string): Decoder<string>;
-export const email: Decoder<string>;
-export const url: Decoder<URL>;
-export const httpsUrl: Decoder<URL>;

package/core/string.js

@@ -1,68 +0,0 @@
-"use strict";
-
-exports.__esModule = true;
-exports.nonEmptyString = exports.httpsUrl = exports.email = void 0;
-exports.regex = regex;
-exports.url = exports.string = void 0;
-
-var _annotate = require("../annotate");
-
-var _either = require("./either");
-
-var _result = require("../result");
-
-var _instanceOf = require("./instanceOf");
-
-var _composition = require("./composition");
-
-/** Match groups in this regex:
- * \1 - the scheme
- * \2 - the username/password (optional)
- * \3 - the host
- * \4 - the port (optional)
- * \5 - the path (optional)
- */
-var url_re = /^([A-Za-z]{3,9}(?:[+][A-Za-z]{3,9})?):\/\/(?:([-;:&=+$,\w]+)@)?(?:([A-Za-z0-9.-]+)(?::([0-9]{2,5}))?)(\/(?:[-+~%/.,\w]*)?(?:\?[-+=&;%@.,\w]*)?(?:#[.,!/\w]*)?)?$/;
-/**
- * Decoder that only returns Ok for string inputs.  Err otherwise.
- */
-
-var string = function string(blob) {
-  return typeof blob === 'string' ? (0, _result.ok)(blob) : (0, _result.err)((0, _annotate.annotate)(blob, 'Must be string'));
-};
-/**
- * Decoder that only returns Ok for non-empty string inputs.  Err otherwise.
- */
-
-
-exports.string = string;
-var nonEmptyString = regex(/\S/, 'Must be non-empty string');
-/**
- * Decoder that only returns Ok for string inputs that match the regular
- * expression.  Err otherwise.  Will always validate that the input is a string
- * before testing the regex.
- */
-
-exports.nonEmptyString = nonEmptyString;
-
-function regex(regex, msg) {
-  return (0, _composition.predicate)(string, function (s) {
-    return regex.test(s);
-  }, msg);
-}
-/**
- * Decoder that only returns Ok for string inputs that match the almost perfect
- * email regex, taken from http://emailregex.com.  Err otherwise.
- */
-
-
-var email = regex(/^(([^<>()[\]\\.,;:\s@"]+(\.[^<>()[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/, 'Must be email');
-exports.email = email;
-var url = (0, _either.either)((0, _composition.map)(regex(url_re, 'Must be URL'), function (value) {
-  return new URL(value);
-}), (0, _instanceOf.instanceOf)(URL));
-exports.url = url;
-var httpsUrl = (0, _composition.predicate)(url, function (value) {
-  return value.protocol === 'https:';
-}, 'Must be an HTTPS URL');
-exports.httpsUrl = httpsUrl;

package/core/string.js.flow

@@ -1,59 +0,0 @@
-// @flow strict
-
-import { annotate } from '../annotate';
-import { either } from './either';
-import { err, ok } from '../result';
-import { instanceOf } from './instanceOf';
-import { map, predicate } from './composition';
-import type { Decoder } from '../_types';
-
-/** Match groups in this regex:
- * \1 - the scheme
- * \2 - the username/password (optional)
- * \3 - the host
- * \4 - the port (optional)
- * \5 - the path (optional)
- */
-const url_re =
-    /^([A-Za-z]{3,9}(?:[+][A-Za-z]{3,9})?):\/\/(?:([-;:&=+$,\w]+)@)?(?:([A-Za-z0-9.-]+)(?::([0-9]{2,5}))?)(\/(?:[-+~%/.,\w]*)?(?:\?[-+=&;%@.,\w]*)?(?:#[.,!/\w]*)?)?$/;
-
-/**
- * Decoder that only returns Ok for string inputs.  Err otherwise.
- */
-export const string: Decoder<string> = (blob: mixed) => {
-    return typeof blob === 'string' ? ok(blob) : err(annotate(blob, 'Must be string'));
-};
-
-/**
- * Decoder that only returns Ok for non-empty string inputs.  Err otherwise.
- */
-export const nonEmptyString: Decoder<string> = regex(/\S/, 'Must be non-empty string');
-
-/**
- * Decoder that only returns Ok for string inputs that match the regular
- * expression.  Err otherwise.  Will always validate that the input is a string
- * before testing the regex.
- */
-export function regex(regex: RegExp, msg: string): Decoder<string> {
-    return predicate(string, (s) => regex.test(s), msg);
-}
-
-/**
- * Decoder that only returns Ok for string inputs that match the almost perfect
- * email regex, taken from http://emailregex.com.  Err otherwise.
- */
-export const email: Decoder<string> = regex(
-    /^(([^<>()[\]\\.,;:\s@"]+(\.[^<>()[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/,
-    'Must be email',
-);
-
-export const url: Decoder<URL> = either(
-    map(regex(url_re, 'Must be URL'), (value) => new URL(value)),
-    instanceOf(URL),
-);
-
-export const httpsUrl: Decoder<URL> = predicate(
-    url,
-    (value) => value.protocol === 'https:',
-    'Must be an HTTPS URL',
-);

package/core/string.mjs

@@ -1,49 +0,0 @@
-import { annotate } from '../annotate.mjs';
-import { either } from './either.mjs';
-import { err, ok } from '../result.mjs';
-import { instanceOf } from './instanceOf.mjs';
-import { map, predicate } from './composition.mjs';
-
-/** Match groups in this regex:
- * \1 - the scheme
- * \2 - the username/password (optional)
- * \3 - the host
- * \4 - the port (optional)
- * \5 - the path (optional)
- */
-var url_re = /^([A-Za-z]{3,9}(?:[+][A-Za-z]{3,9})?):\/\/(?:([-;:&=+$,\w]+)@)?(?:([A-Za-z0-9.-]+)(?::([0-9]{2,5}))?)(\/(?:[-+~%/.,\w]*)?(?:\?[-+=&;%@.,\w]*)?(?:#[.,!/\w]*)?)?$/;
-/**
- * Decoder that only returns Ok for string inputs.  Err otherwise.
- */
-
-export var string = function string(blob) {
-  return typeof blob === 'string' ? ok(blob) : err(annotate(blob, 'Must be string'));
-};
-/**
- * Decoder that only returns Ok for non-empty string inputs.  Err otherwise.
- */
-
-export var nonEmptyString = regex(/\S/, 'Must be non-empty string');
-/**
- * Decoder that only returns Ok for string inputs that match the regular
- * expression.  Err otherwise.  Will always validate that the input is a string
- * before testing the regex.
- */
-
-export function regex(regex, msg) {
-  return predicate(string, function (s) {
-    return regex.test(s);
-  }, msg);
-}
-/**
- * Decoder that only returns Ok for string inputs that match the almost perfect
- * email regex, taken from http://emailregex.com.  Err otherwise.
- */
-
-export var email = regex(/^(([^<>()[\]\\.,;:\s@"]+(\.[^<>()[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/, 'Must be email');
-export var url = either(map(regex(url_re, 'Must be URL'), function (value) {
-  return new URL(value);
-}), instanceOf(URL));
-export var httpsUrl = predicate(url, function (value) {
-  return value.protocol === 'https:';
-}, 'Must be an HTTPS URL');

package/core/tuple.d.ts

@@ -1,30 +0,0 @@
-import { Decoder } from '../_types';
-
-export function tuple1<T1>(d1: Decoder<T1>): Decoder<[T1]>;
-export function tuple2<T1, T2>(d1: Decoder<T1>, d2: Decoder<T2>): Decoder<[T1, T2]>;
-export function tuple3<T1, T2, T3>(
-    d1: Decoder<T1>,
-    d2: Decoder<T2>,
-    d3: Decoder<T3>,
-): Decoder<[T1, T2, T3]>;
-export function tuple4<T1, T2, T3, T4>(
-    d1: Decoder<T1>,
-    d2: Decoder<T2>,
-    d3: Decoder<T3>,
-    d4: Decoder<T4>,
-): Decoder<[T1, T2, T3, T4]>;
-export function tuple5<T1, T2, T3, T4, T5>(
-    d1: Decoder<T1>,
-    d2: Decoder<T2>,
-    d3: Decoder<T3>,
-    d4: Decoder<T4>,
-    d5: Decoder<T5>,
-): Decoder<[T1, T2, T3, T4, T5]>;
-export function tuple6<T1, T2, T3, T4, T5, T6>(
-    d1: Decoder<T1>,
-    d2: Decoder<T2>,
-    d3: Decoder<T3>,
-    d4: Decoder<T4>,
-    d5: Decoder<T5>,
-    d6: Decoder<T6>,
-): Decoder<[T1, T2, T3, T4, T5, T6]>;