decoders 2.0.0-beta7 → 2.0.0-beta8

package/core/array.js

@@ -98,7 +98,7 @@ function array(decoder) {
 
 
 function nonEmptyArray(decoder) {
-  return (0, _composition.compose)(array(decoder), (0, _composition.predicate)(function (arr) {
+  return (0, _composition.predicate)(array(decoder), function (arr) {
     return arr.length > 0;
-  }, 'Must be non-empty array'));
+  }, 'Must be non-empty array');
 }

package/core/array.js.flow

@@ -96,8 +96,5 @@ export function array<T>(decoder: Decoder<T>): Decoder<Array<T>> {
  * empty arrays.
  */
 export function nonEmptyArray<T>(decoder: Decoder<T>): Decoder<Array<T>> {
-    return compose(
-        array(decoder),
-        predicate((arr) => arr.length > 0, 'Must be non-empty array'),
-    );
+    return predicate(array(decoder), (arr) => arr.length > 0, 'Must be non-empty array');
 }

package/core/array.mjs

@@ -85,7 +85,7 @@ export function array(decoder) {
  */
 
 export function nonEmptyArray(decoder) {
-  return compose(array(decoder), predicate(function (arr) {
+  return predicate(array(decoder), function (arr) {
     return arr.length > 0;
-  }, 'Must be non-empty array'));
+  }, 'Must be non-empty array');
 }

package/core/composition.d.ts

@@ -2,11 +2,13 @@ import { Decoder } from '../_types';
 
 export function map<T, V>(decoder: Decoder<T>, mapper: (value: T) => V): Decoder<V>;
 export function compose<T, V>(decoder: Decoder<T>, next: Decoder<V, T>): Decoder<V>;
-export function predicate<T extends F, F = unknown>(
-    predicate: (value: F) => value is T,
+export function predicate<T, N extends T>(
+    decoder: Decoder<T>,
+    predicate: (value: T) => value is N,
     msg: string,
-): Decoder<T, F>;
+): Decoder<N>;
 export function predicate<T>(
+    decoder: Decoder<T>,
     predicate: (value: T) => boolean,
     msg: string,
-): Decoder<T, T>;
+): Decoder<T>;

package/core/composition.js

@@ -45,8 +45,10 @@ function compose(decoder, next) {
  */
 
 
-function predicate(predicateFn, msg) {
-  return function (value) {
-    return predicateFn(value) ? (0, _result.ok)(value) : (0, _result.err)((0, _annotate.annotate)(value, msg));
+function predicate(decoder, predicateFn, msg) {
+  return function (blob) {
+    return (0, _result.andThen)(decoder(blob), function (value) {
+      return predicateFn(value) ? (0, _result.ok)(value) : (0, _result.err)((0, _annotate.annotate)(value, msg));
+    });
   };
 }

package/core/composition.js.flow

@@ -36,8 +36,13 @@ export function compose<T, V>(decoder: Decoder<T>, next: Decoder<V, T>): Decoder
  * Factory function returning a Decoder<T>, given a predicate function that
  * accepts/rejects the input of type T.
  */
-export function predicate<T>(predicateFn: (T) => boolean, msg: string): Decoder<T, T> {
-    return (value: T) => {
-        return predicateFn(value) ? ok(value) : err(annotate(value, msg));
-    };
+export function predicate<T>(
+    decoder: Decoder<T>,
+    predicateFn: (T) => boolean,
+    msg: string,
+): Decoder<T> {
+    return (blob: mixed) =>
+        andThen(decoder(blob), (value) =>
+            predicateFn(value) ? ok(value) : err(annotate(value, msg)),
+        );
 }

package/core/composition.mjs

@@ -35,8 +35,10 @@ export function compose(decoder, next) {
  * accepts/rejects the input of type T.
  */
 
-export function predicate(predicateFn, msg) {
-  return function (value) {
-    return predicateFn(value) ? ok(value) : err(annotate(value, msg));
+export function predicate(decoder, predicateFn, msg) {
+  return function (blob) {
+    return andThen(decoder(blob), function (value) {
+      return predicateFn(value) ? ok(value) : err(annotate(value, msg));
+    });
   };
 }

package/core/dispatch.d.ts

@@ -1,8 +1,8 @@
 import { Decoder, DecoderType } from '../_types';
 
-export type $Values<T extends object> = T[keyof T];
+export type Values<T extends object> = T[keyof T];
 
-export function dispatch<O extends { [key: string]: Decoder<any> }>(
+export function disjointUnion<O extends { [key: string]: Decoder<any> }>(
     field: string,
     mapping: O,
-): Decoder<$Values<{ [key in keyof O]: DecoderType<O[key]> }>>;
+): Decoder<Values<{ [key in keyof O]: DecoderType<O[key]> }>>;

package/core/dispatch.js

@@ -1,7 +1,7 @@
 "use strict";
 
 exports.__esModule = true;
-exports.dispatch = dispatch;
+exports.disjointUnion = disjointUnion;
 
 var _result = require("../result");
 
@@ -31,20 +31,20 @@ var _either = require("./either");
  * Then these two decoders are equivalent:
  *
  *     const shape = either(rectangle, circle)
- *     const shape = dispatch('type', { rectangle, circle })
+ *     const shape = disjointUnion('type', { rectangle, circle })
  *
  * Will be of type Decoder<Rectangle | Circle>.
  *
- * But the dispatch version will typically be more runtime-efficient.  The
- * reason is that it will first do minimal work to "look ahead" into the `type`
- * field here, and based on that value, pick the decoder to invoke.
+ * But `disjointUnion` will typically be more runtime-efficient.  The reason is
+ * that it will first do minimal work to "look ahead" into the `type` field
+ * here, and based on that value, pick the decoder to invoke.
  *
  * The `either` version will simply try to invoke each decoder, until it finds
  * one that matches.
  *
- * Also, the error messages will be less ambiguous using `dispatch()`.
+ * Also, the error messages will be less ambiguous using `disjointUnion()`.
  */
-function dispatch(field, mapping) {
+function disjointUnion(field, mapping) {
   var _object;
 
   var base = (0, _object2.object)((_object = {}, _object[field] = (0, _either.oneOf)(Object.keys(mapping)), _object));

package/core/dispatch.js.flow

@@ -30,20 +30,20 @@ type anything = any;
  * Then these two decoders are equivalent:
  *
  *     const shape = either(rectangle, circle)
- *     const shape = dispatch('type', { rectangle, circle })
+ *     const shape = disjointUnion('type', { rectangle, circle })
  *
  * Will be of type Decoder<Rectangle | Circle>.
  *
- * But the dispatch version will typically be more runtime-efficient.  The
- * reason is that it will first do minimal work to "look ahead" into the `type`
- * field here, and based on that value, pick the decoder to invoke.
+ * But `disjointUnion` will typically be more runtime-efficient.  The reason is
+ * that it will first do minimal work to "look ahead" into the `type` field
+ * here, and based on that value, pick the decoder to invoke.
  *
  * The `either` version will simply try to invoke each decoder, until it finds
  * one that matches.
  *
- * Also, the error messages will be less ambiguous using `dispatch()`.
+ * Also, the error messages will be less ambiguous using `disjointUnion()`.
  */
-export function dispatch<O: { +[field: string]: Decoder<anything>, ... }>(
+export function disjointUnion<O: { +[field: string]: Decoder<anything>, ... }>(
     field: string,
     mapping: O,
 ): Decoder<$Values<$ObjMap<O, DecoderType>>> {

package/core/dispatch.mjs

@@ -24,20 +24,20 @@ import { oneOf } from './either.mjs';
  * Then these two decoders are equivalent:
  *
  *     const shape = either(rectangle, circle)
- *     const shape = dispatch('type', { rectangle, circle })
+ *     const shape = disjointUnion('type', { rectangle, circle })
  *
  * Will be of type Decoder<Rectangle | Circle>.
  *
- * But the dispatch version will typically be more runtime-efficient.  The
- * reason is that it will first do minimal work to "look ahead" into the `type`
- * field here, and based on that value, pick the decoder to invoke.
+ * But `disjointUnion` will typically be more runtime-efficient.  The reason is
+ * that it will first do minimal work to "look ahead" into the `type` field
+ * here, and based on that value, pick the decoder to invoke.
  *
  * The `either` version will simply try to invoke each decoder, until it finds
  * one that matches.
  *
- * Also, the error messages will be less ambiguous using `dispatch()`.
+ * Also, the error messages will be less ambiguous using `disjointUnion()`.
  */
-export function dispatch(field, mapping) {
+export function disjointUnion(field, mapping) {
   var _object;
 
   var base = object((_object = {}, _object[field] = oneOf(Object.keys(mapping)), _object));

package/core/mapping.js

@@ -13,17 +13,11 @@ var _result = require("../result");
 var _object = require("./object");
 
 /**
- * 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)
- *
+ * Like mapping(), but returns an object rather than a Map instance.
  */
-function mapping(decoder) {
+function dict(decoder) {
   return (0, _composition.compose)(_object.pojo, function (blob) {
-    var tuples = [];
+    var rv = {};
     var errors = null;
     Object.keys(blob).forEach(function (key) {
       var value = blob[key];
@@ -31,10 +25,10 @@ function mapping(decoder) {
 
       if (result.type === 'ok') {
         if (errors === null) {
-          tuples.push([key, result.value]);
+          rv[key] = result.value;
         }
       } else {
-        tuples.length = 0; // Clear the tuples array
+        rv = {}; // Clear the success value so it can get garbage collected early
 
         if (errors === null) {
           errors = {};
@@ -47,17 +41,27 @@ function mapping(decoder) {
     if (errors !== null) {
       return (0, _result.err)((0, _annotate.merge)((0, _annotate.annotateObject)(blob), errors));
     } else {
-      return (0, _result.ok)(new Map(tuples));
+      return (0, _result.ok)(rv);
     }
   });
 }
 /**
- * Like mapping(), but returns an object rather than a Map instance.
+ * 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 dict(decoder) {
-  return (0, _composition.map)(mapping(decoder), function (m) {
-    return Object.fromEntries(m);
+function mapping(decoder) {
+  return (0, _composition.map)(dict(decoder), 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]];
+    }));
   });
 }

package/core/mapping.js.flow

@@ -9,17 +9,11 @@ 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)
- *
+ * Like mapping(), but returns an object rather than a Map instance.
  */
-export function mapping<T>(decoder: Decoder<T>): Decoder<Map<string, T>> {
+export function dict<T>(decoder: Decoder<T>): Decoder<{ [string]: T }> {
     return compose(pojo, (blob: { +[key: string]: mixed }) => {
-        let tuples: Array<[string, T]> = [];
+        let rv: { [key: string]: T } = {};
         let errors: { [key: string]: Annotation } | null = null;
 
         Object.keys(blob).forEach((key: string) => {
@@ -27,10 +21,10 @@ export function mapping<T>(decoder: Decoder<T>): Decoder<Map<string, T>> {
             const result = decoder(value);
             if (result.type === 'ok') {
                 if (errors === null) {
-                    tuples.push([key, result.value]);
+                    rv[key] = result.value;
                 }
             } else {
-                tuples.length = 0; // Clear the tuples array
+                rv = {}; // Clear the success value so it can get garbage collected early
                 if (errors === null) {
                     errors = {};
                 }
@@ -41,14 +35,28 @@ export function mapping<T>(decoder: Decoder<T>): Decoder<Map<string, T>> {
         if (errors !== null) {
             return err(merge(annotateObject(blob), errors));
         } else {
-            return ok(new Map(tuples));
+            return ok(rv);
         }
     });
 }
 
 /**
- * Like mapping(), but returns an object rather than a Map instance.
+ * 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 dict<T>(decoder: Decoder<T>): Decoder<{ [string]: T }> {
-    return map(mapping(decoder), (m) => Object.fromEntries(m));
+export function mapping<T>(decoder: Decoder<T>): Decoder<Map<string, T>> {
+    return map(
+        dict(decoder),
+        (obj) =>
+            new Map(
+                // This is effectively Object.entries(obj), but in a way that Flow
+                // will know the types are okay
+                Object.keys(obj).map((key) => [key, obj[key]]),
+            ),
+    );
 }

package/core/mapping.mjs

@@ -5,17 +5,11 @@ import { merge } from '../annotate.mjs';
 import { pojo } from './object.mjs';
 
 /**
- * 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)
- *
+ * Like mapping(), but returns an object rather than a Map instance.
  */
-export function mapping(decoder) {
+export function dict(decoder) {
   return compose(pojo, function (blob) {
-    var tuples = [];
+    var rv = {};
     var errors = null;
     Object.keys(blob).forEach(function (key) {
       var value = blob[key];
@@ -23,10 +17,10 @@ export function mapping(decoder) {
 
       if (result.type === 'ok') {
         if (errors === null) {
-          tuples.push([key, result.value]);
+          rv[key] = result.value;
         }
       } else {
-        tuples.length = 0; // Clear the tuples array
+        rv = {}; // Clear the success value so it can get garbage collected early
 
         if (errors === null) {
           errors = {};
@@ -39,16 +33,26 @@ export function mapping(decoder) {
     if (errors !== null) {
       return err(merge(annotateObject(blob), errors));
     } else {
-      return ok(new Map(tuples));
+      return ok(rv);
     }
   });
 }
 /**
- * Like mapping(), but returns an object rather than a Map instance.
+ * 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 dict(decoder) {
-  return map(mapping(decoder), function (m) {
-    return Object.fromEntries(m);
+export function mapping(decoder) {
+  return map(dict(decoder), 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]];
+    }));
   });
 }

package/core/number.js

@@ -5,10 +5,10 @@ exports.positiveNumber = exports.positiveInteger = exports.number = exports.inte
 
 var _annotate = require("../annotate");
 
-var _composition = require("./composition");
-
 var _result = require("../result");
 
+var _composition = require("./composition");
+
 var anyNumber = function anyNumber(blob) {
   return typeof blob === 'number' && !Number.isNaN(blob) ? (0, _result.ok)(blob) : (0, _result.err)((0, _annotate.annotate)(blob, 'Must be number'));
 };
@@ -21,16 +21,16 @@ var isFinite = function isFinite(n) {
   return Number.isFinite(n);
 };
 
-var number = (0, _composition.compose)(anyNumber, (0, _composition.predicate)(isFinite, 'Number must be finite'));
+var number = (0, _composition.predicate)(anyNumber, isFinite, 'Number must be finite');
 exports.number = number;
-var positiveNumber = (0, _composition.compose)(number, (0, _composition.predicate)(function (n) {
+var positiveNumber = (0, _composition.predicate)(number, function (n) {
   return n >= 0;
-}, 'Number must be positive')); // Integers
+}, 'Number must be positive'); // Integers
 
 exports.positiveNumber = positiveNumber;
-var integer = (0, _composition.compose)(number, (0, _composition.predicate)(isInteger, 'Number must be an integer'));
+var integer = (0, _composition.predicate)(number, isInteger, 'Number must be an integer');
 exports.integer = integer;
-var positiveInteger = (0, _composition.compose)(integer, (0, _composition.predicate)(function (n) {
+var positiveInteger = (0, _composition.predicate)(integer, function (n) {
   return n >= 0;
-}, 'Number must be positive'));
+}, 'Number must be positive');
 exports.positiveInteger = positiveInteger;

package/core/number.js.flow

@@ -1,8 +1,8 @@
 // @flow strict
 
 import { annotate } from '../annotate';
-import { compose, predicate } from './composition';
 import { err, ok } from '../result';
+import { predicate } from './composition';
 import type { Decoder } from '../_types';
 
 const anyNumber: Decoder<number> = (blob: mixed) => {
@@ -14,21 +14,27 @@ const anyNumber: Decoder<number> = (blob: mixed) => {
 const isInteger = (n: number) => Number.isInteger(n);
 const isFinite = (n: number) => Number.isFinite(n);
 
-export const number: Decoder<number> = compose(
+export const number: Decoder<number> = predicate(
     anyNumber,
-    predicate(isFinite, 'Number must be finite'),
+    isFinite,
+    'Number must be finite',
 );
-export const positiveNumber: Decoder<number> = compose(
+
+export const positiveNumber: Decoder<number> = predicate(
     number,
-    predicate((n) => n >= 0, 'Number must be positive'),
+    (n) => n >= 0,
+    'Number must be positive',
 );
 
 // Integers
-export const integer: Decoder<number> = compose(
+export const integer: Decoder<number> = predicate(
     number,
-    predicate(isInteger, 'Number must be an integer'),
+    isInteger,
+    'Number must be an integer',
 );
-export const positiveInteger: Decoder<number> = compose(
+
+export const positiveInteger: Decoder<number> = predicate(
     integer,
-    predicate((n) => n >= 0, 'Number must be positive'),
+    (n) => n >= 0,
+    'Number must be positive',
 );

package/core/number.mjs

@@ -1,6 +1,6 @@
 import { annotate } from '../annotate.mjs';
-import { compose, predicate } from './composition.mjs';
 import { err, ok } from '../result.mjs';
+import { predicate } from './composition.mjs';
 
 var anyNumber = function anyNumber(blob) {
   return typeof blob === 'number' && !Number.isNaN(blob) ? ok(blob) : err(annotate(blob, 'Must be number'));
@@ -14,12 +14,12 @@ var isFinite = function isFinite(n) {
   return Number.isFinite(n);
 };
 
-export var number = compose(anyNumber, predicate(isFinite, 'Number must be finite'));
-export var positiveNumber = compose(number, predicate(function (n) {
+export var number = predicate(anyNumber, isFinite, 'Number must be finite');
+export var positiveNumber = predicate(number, function (n) {
   return n >= 0;
-}, 'Number must be positive')); // Integers
+}, 'Number must be positive'); // Integers
 
-export var integer = compose(number, predicate(isInteger, 'Number must be an integer'));
-export var positiveInteger = compose(integer, predicate(function (n) {
+export var integer = predicate(number, isInteger, 'Number must be an integer');
+export var positiveInteger = predicate(integer, function (n) {
   return n >= 0;
-}, 'Number must be positive'));
+}, 'Number must be positive');

package/core/string.d.ts

@@ -1,7 +1,10 @@
+/// <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 function url(schemes?: readonly string[]): Decoder<string>;
+export const url: Decoder<URL>;
+export const httpsUrl: Decoder<URL>;

package/core/string.js

@@ -1,16 +1,20 @@
 "use strict";
 
 exports.__esModule = true;
-exports.nonEmptyString = exports.email = void 0;
+exports.nonEmptyString = exports.httpsUrl = exports.email = void 0;
 exports.regex = regex;
 exports.url = exports.string = void 0;
 
 var _annotate = require("../annotate");
 
-var _composition = require("./composition");
+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)
@@ -18,9 +22,7 @@ var _result = require("../result");
  * \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]*)?)?$/; // The URL schemes the url() decoder accepts by default
-
-var DEFAULT_SCHEMES = ['https'];
+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.
  */
@@ -44,9 +46,9 @@ var nonEmptyString = regex(/\S/, 'Must be non-empty string');
 exports.nonEmptyString = nonEmptyString;
 
 function regex(regex, msg) {
-  return (0, _composition.compose)(string, (0, _composition.predicate)(function (s) {
+  return (0, _composition.predicate)(string, function (s) {
     return regex.test(s);
-  }, msg));
+  }, msg);
 }
 /**
  * Decoder that only returns Ok for string inputs that match the almost perfect
@@ -55,40 +57,12 @@ function regex(regex, msg) {
 
 
 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');
-/**
- * Decoder that only returns Ok for string inputs that match URLs of the
- * expected scheme.  Defaults to only accept HTTPS URLs.  Err otherwise.
- *
- * Variants that can be used:
- *
- * - url()                      accepts only https:// URLs
- * - url([])                    accepts any URL scheme
- * - url(['http'])              accepts only HTTP
- * - url(['https', 'git+ssh'])  accepts both https:// and git+ssh:// URLs
- */
-
 exports.email = email;
-
-var url = function url(schemes) {
-  if (schemes === void 0) {
-    schemes = DEFAULT_SCHEMES;
-  }
-
-  return (0, _composition.compose)(string, function (value) {
-    var matches = value.match(url_re);
-
-    if (!matches) {
-      return (0, _result.err)((0, _annotate.annotate)(value, 'Must be URL'));
-    } else {
-      var scheme = matches[1];
-
-      if (schemes.length === 0 || schemes.includes(scheme.toLowerCase())) {
-        return (0, _result.ok)(value);
-      } else {
-        return (0, _result.err)((0, _annotate.annotate)(value, "URL scheme must be any of: " + schemes.join(', ')));
-      }
-    }
-  });
-};
-
-exports.url = url;
+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;