decoders 2.0.0-beta8 → 2.0.0-beta9

package/core/object.mjs

@@ -1,7 +1,7 @@
 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 { compose, transform } from './composition.mjs';
 import { err, ok } from '../result.mjs';
 
 function isPojo(o) {
@@ -74,7 +74,7 @@ export function object(mapping) {
       var rawValue = blob[key];
       var result = decoder(rawValue);
 
-      if (result.type === 'ok') {
+      if (result.ok) {
         var value = result.value;
 
         if (value !== undefined) {
@@ -150,7 +150,7 @@ export function exact(mapping) {
 export function inexact(mapping) {
   return compose(pojo, function (blob) {
     var allkeys = new Set(Object.keys(blob));
-    var decoder = map(object(mapping), function (safepart) {
+    var decoder = transform(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) {
@@ -172,4 +172,57 @@ export function inexact(mapping) {
     });
     return decoder(blob);
   });
+}
+/**
+ * Like mapping(), but returns an object rather than a Map instance.
+ */
+
+export function dict(decoder) {
+  return compose(pojo, function (blob) {
+    var rv = {};
+    var errors = null;
+    Object.keys(blob).forEach(function (key) {
+      var value = blob[key];
+      var result = decoder(value);
+
+      if (result.ok) {
+        if (errors === null) {
+          rv[key] = result.value;
+        }
+      } else {
+        rv = {}; // Clear the success value so it can get garbage collected early
+
+        if (errors === null) {
+          errors = {};
+        }
+
+        errors[key] = result.error;
+      }
+    });
+
+    if (errors !== null) {
+      return err(merge(annotateObject(blob), errors));
+    } else {
+      return ok(rv);
+    }
+  });
+}
+/**
+ * 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(decoder) {
+  return transform(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/string.d.ts

@@ -8,3 +8,6 @@ export function regex(regex: RegExp, msg: string): Decoder<string>;
 export const email: Decoder<string>;
 export const url: Decoder<URL>;
 export const httpsUrl: Decoder<URL>;
+export const uuid: Decoder<string>;
+export const uuidv1: Decoder<string>;
+export const uuidv4: Decoder<string>;

package/core/string.js

@@ -3,7 +3,7 @@
 exports.__esModule = true;
 exports.nonEmptyString = exports.httpsUrl = exports.email = void 0;
 exports.regex = regex;
-exports.url = exports.string = void 0;
+exports.uuidv4 = exports.uuidv1 = exports.uuid = exports.url = exports.string = void 0;
 
 var _annotate = require("../annotate");
 
@@ -58,11 +58,23 @@ 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');
 exports.email = email;
-var url = (0, _either.either)((0, _composition.map)(regex(url_re, 'Must be URL'), function (value) {
+var url = (0, _either.either)((0, _composition.transform)(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;
+exports.httpsUrl = httpsUrl;
+var uuid = regex(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i, 'Must be uuid');
+exports.uuid = uuid;
+var uuidv1 = // https://en.wikipedia.org/wiki/Universally_unique_identifier#Version_1_(date-time_and_MAC_address)
+(0, _composition.predicate)(uuid, function (value) {
+  return value[14] === '1';
+}, 'Must be uuidv1');
+exports.uuidv1 = uuidv1;
+var uuidv4 = // https://en.wikipedia.org/wiki/Universally_unique_identifier#Version_4_(random)
+(0, _composition.predicate)(uuid, function (value) {
+  return value[14] === '4';
+}, 'Must be uuidv4');
+exports.uuidv4 = uuidv4;

package/core/string.js.flow

@@ -4,7 +4,7 @@ import { annotate } from '../annotate';
 import { either } from './either';
 import { err, ok } from '../result';
 import { instanceOf } from './instanceOf';
-import { map, predicate } from './composition';
+import { predicate, transform } from './composition';
 import type { Decoder } from '../_types';
 
 /** Match groups in this regex:
@@ -48,7 +48,7 @@ export const email: Decoder<string> = regex(
 );
 
 export const url: Decoder<URL> = either(
-    map(regex(url_re, 'Must be URL'), (value) => new URL(value)),
+    transform(regex(url_re, 'Must be URL'), (value) => new URL(value)),
     instanceOf(URL),
 );
 
@@ -57,3 +57,16 @@ export const httpsUrl: Decoder<URL> = predicate(
     (value) => value.protocol === 'https:',
     'Must be an HTTPS URL',
 );
+
+export const uuid: Decoder<string> = regex(
+    /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i,
+    'Must be uuid',
+);
+
+export const uuidv1: Decoder<string> =
+    // https://en.wikipedia.org/wiki/Universally_unique_identifier#Version_1_(date-time_and_MAC_address)
+    predicate(uuid, (value) => value[14] === '1', 'Must be uuidv1');
+
+export const uuidv4: Decoder<string> =
+    // https://en.wikipedia.org/wiki/Universally_unique_identifier#Version_4_(random)
+    predicate(uuid, (value) => value[14] === '4', 'Must be uuidv4');

package/core/string.mjs

@@ -2,7 +2,7 @@ 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';
+import { predicate, transform } from './composition.mjs';
 
 /** Match groups in this regex:
  * \1 - the scheme
@@ -41,9 +41,18 @@ export function regex(regex, msg) {
  */
 
 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) {
+export var url = either(transform(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');
+}, 'Must be an HTTPS URL');
+export var uuid = regex(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i, 'Must be uuid');
+export var uuidv1 = // https://en.wikipedia.org/wiki/Universally_unique_identifier#Version_1_(date-time_and_MAC_address)
+predicate(uuid, function (value) {
+  return value[14] === '1';
+}, 'Must be uuidv1');
+export var uuidv4 = // https://en.wikipedia.org/wiki/Universally_unique_identifier#Version_4_(random)
+predicate(uuid, function (value) {
+  return value[14] === '4';
+}, 'Must be uuidv4');

package/core/tuple.d.ts

@@ -1,30 +1,30 @@
 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]>;
+export function tuple<A>(a: Decoder<A>): Decoder<[A]>;
+export function tuple<A, B>(a: Decoder<A>, b: Decoder<B>): Decoder<[A, B]>;
+export function tuple<A, B, C>(
+    a: Decoder<A>,
+    b: Decoder<B>,
+    c: Decoder<C>,
+): Decoder<[A, B, C]>;
+export function tuple<A, B, C, D>(
+    a: Decoder<A>,
+    b: Decoder<B>,
+    c: Decoder<C>,
+    d: Decoder<D>,
+): Decoder<[A, B, C, D]>;
+export function tuple<A, B, C, D, E>(
+    a: Decoder<A>,
+    b: Decoder<B>,
+    c: Decoder<C>,
+    d: Decoder<D>,
+    e: Decoder<E>,
+): Decoder<[A, B, C, D, E]>;
+export function tuple<A, B, C, D, E, F>(
+    a: Decoder<A>,
+    b: Decoder<B>,
+    c: Decoder<C>,
+    d: Decoder<D>,
+    e: Decoder<E>,
+    f: Decoder<F>,
+): Decoder<[A, B, C, D, E, F]>;

package/core/tuple.js

@@ -1,12 +1,7 @@
 "use strict";
 
 exports.__esModule = true;
-exports.tuple1 = tuple1;
-exports.tuple2 = tuple2;
-exports.tuple3 = tuple3;
-exports.tuple4 = tuple4;
-exports.tuple5 = tuple5;
-exports.tuple6 = tuple6;
+exports.tuple = void 0;
 
 var _annotate = require("../annotate");
 
@@ -16,162 +11,44 @@ var _result = require("../result");
 
 var _array = require("./array");
 
-function okOrErr(result) {
-  return result.type === 'ok' ? result.value : result.error;
-}
-
 var ntuple = function ntuple(n) {
   return (0, _composition.predicate)(_array.poja, function (arr) {
     return arr.length === n;
   }, "Must be a " + n + "-tuple");
-};
-/**
- * Builds a Decoder that returns Ok for 1-tuple of [T], given a Decoder for T.
- * Err otherwise.
- */
-
-
-function tuple1(decoder1) {
-  return (0, _composition.compose)(ntuple(1), function (blobs) {
-    var blob1 = blobs[0];
-    var result1 = decoder1(blob1);
-
-    try {
-      return (0, _result.ok)([(0, _result.unwrap)(result1)]);
-    } catch (e) {
-      // If a decoder error has happened while unwrapping all the
-      // results, try to construct a good error message
-      return (0, _result.err)((0, _annotate.annotate)([okOrErr(result1)]));
-    }
-  });
-}
-/**
- * Builds a Decoder that returns Ok for 2-tuples of [T1, T2], given Decoders
- * for T1 and T2.  Err otherwise.
- */
-
+}; // prettier-ignore
 
-function tuple2(decoder1, decoder2) {
-  return (0, _composition.compose)(ntuple(2), function (blobs) {
-    var blob1 = blobs[0],
-        blob2 = blobs[1];
-    var result1 = decoder1(blob1);
-    var result2 = decoder2(blob2);
 
-    try {
-      return (0, _result.ok)([(0, _result.unwrap)(result1), (0, _result.unwrap)(result2)]);
-    } catch (e) {
-      // If a decoder error has happened while unwrapping all the
-      // results, try to construct a good error message
-      return (0, _result.err)((0, _annotate.annotate)([okOrErr(result1), okOrErr(result2)]));
-    }
-  });
-}
 /**
- * Builds a Decoder that returns Ok for 3-tuples of [T1, T2, T3], given
- * Decoders for T1, T2, and T3.  Err otherwise.
+ * Accepts n-tuples [A, B, C, ...] matching the given decoders A, B, C, ...
  */
-
-
-function tuple3(decoder1, decoder2, decoder3) {
-  return (0, _composition.compose)(ntuple(3), function (blobs) {
-    var blob1 = blobs[0],
-        blob2 = blobs[1],
-        blob3 = blobs[2];
-    var result1 = decoder1(blob1);
-    var result2 = decoder2(blob2);
-    var result3 = decoder3(blob3);
-
-    try {
-      return (0, _result.ok)([(0, _result.unwrap)(result1), (0, _result.unwrap)(result2), (0, _result.unwrap)(result3)]);
-    } catch (e) {
+function _tuple() {
+  for (var _len = arguments.length, decoders = new Array(_len), _key = 0; _key < _len; _key++) {
+    decoders[_key] = arguments[_key];
+  }
+
+  return (0, _composition.compose)(ntuple(decoders.length), function (blobs) {
+    var allOk = true;
+    var rvs = decoders.map(function (decoder, i) {
+      var blob = blobs[i];
+      var result = decoder(blob);
+
+      if (result.ok) {
+        return result.value;
+      } else {
+        allOk = false;
+        return result.error;
+      }
+    });
+
+    if (allOk) {
+      return (0, _result.ok)(rvs);
+    } else {
       // If a decoder error has happened while unwrapping all the
       // results, try to construct a good error message
-      return (0, _result.err)((0, _annotate.annotate)([okOrErr(result1), okOrErr(result2), okOrErr(result3)]));
+      return (0, _result.err)((0, _annotate.annotate)(rvs));
     }
   });
 }
-/**
- * Builds a Decoder that returns Ok for 4-tuples of [T1, T2, T3, T4], given
- * Decoders for T1, T2, T3, and T4.  Err otherwise.
- */
-
 
-function tuple4(decoder1, decoder2, decoder3, decoder4) {
-  return (0, _composition.compose)(ntuple(4), function (blobs) {
-    var blob1 = blobs[0],
-        blob2 = blobs[1],
-        blob3 = blobs[2],
-        blob4 = blobs[3];
-    var result1 = decoder1(blob1);
-    var result2 = decoder2(blob2);
-    var result3 = decoder3(blob3);
-    var result4 = decoder4(blob4);
-
-    try {
-      return (0, _result.ok)([(0, _result.unwrap)(result1), (0, _result.unwrap)(result2), (0, _result.unwrap)(result3), (0, _result.unwrap)(result4)]);
-    } catch (e) {
-      // If a decoder error has happened while unwrapping all the
-      // results, try to construct a good error message
-      return (0, _result.err)((0, _annotate.annotate)([okOrErr(result1), okOrErr(result2), okOrErr(result3), okOrErr(result4)]));
-    }
-  });
-}
-/**
- * Builds a Decoder that returns Ok for 5-tuples of [T1, T2, T3, T4, T5], given
- * Decoders for T1, T2, T3, T4, and T5.  Err otherwise.
- */
-
-
-function tuple5(decoder1, decoder2, decoder3, decoder4, decoder5) {
-  return (0, _composition.compose)(ntuple(5), function (blobs) {
-    var blob1 = blobs[0],
-        blob2 = blobs[1],
-        blob3 = blobs[2],
-        blob4 = blobs[3],
-        blob5 = blobs[4];
-    var result1 = decoder1(blob1);
-    var result2 = decoder2(blob2);
-    var result3 = decoder3(blob3);
-    var result4 = decoder4(blob4);
-    var result5 = decoder5(blob5);
-
-    try {
-      return (0, _result.ok)([(0, _result.unwrap)(result1), (0, _result.unwrap)(result2), (0, _result.unwrap)(result3), (0, _result.unwrap)(result4), (0, _result.unwrap)(result5)]);
-    } catch (e) {
-      // If a decoder error has happened while unwrapping all the
-      // results, try to construct a good error message
-      return (0, _result.err)((0, _annotate.annotate)([okOrErr(result1), okOrErr(result2), okOrErr(result3), okOrErr(result4), okOrErr(result5)]));
-    }
-  });
-}
-/**
- * Builds a Decoder that returns Ok for 5-tuples of [T1, T2, T3, T4, T5], given
- * Decoders for T1, T2, T3, T4, T5, and T6.  Err otherwise.
- */
-
-
-function tuple6(decoder1, decoder2, decoder3, decoder4, decoder5, decoder6) {
-  return (0, _composition.compose)(ntuple(6), function (blobs) {
-    var blob1 = blobs[0],
-        blob2 = blobs[1],
-        blob3 = blobs[2],
-        blob4 = blobs[3],
-        blob5 = blobs[4],
-        blob6 = blobs[5];
-    var result1 = decoder1(blob1);
-    var result2 = decoder2(blob2);
-    var result3 = decoder3(blob3);
-    var result4 = decoder4(blob4);
-    var result5 = decoder5(blob5);
-    var result6 = decoder6(blob6);
-
-    try {
-      return (0, _result.ok)([(0, _result.unwrap)(result1), (0, _result.unwrap)(result2), (0, _result.unwrap)(result3), (0, _result.unwrap)(result4), (0, _result.unwrap)(result5), (0, _result.unwrap)(result6)]);
-    } catch (e) {
-      // If a decoder error has happened while unwrapping all the
-      // results, try to construct a good error message
-      return (0, _result.err)((0, _annotate.annotate)([okOrErr(result1), okOrErr(result2), okOrErr(result3), okOrErr(result4), okOrErr(result5), okOrErr(result6)]));
-    }
-  });
-}
+var tuple = _tuple;
+exports.tuple = tuple;