decoders 1.25.5 → 2.0.0-beta2

package/_esm/core/array.js

@@ -0,0 +1,91 @@
+import * as Result from '../result';
+import { annotate } from '../annotate';
+import { compose, predicate } from './composition';
+
+/**
+ * Like a "Plain Old JavaScript Object", but for arrays: "Plain Old JavaScript
+ * Array" ^_^
+ */
+export var poja = function poja(blob) {
+  if (!Array.isArray(blob)) {
+    return Result.err(annotate(blob, 'Must be an array'));
+  }
+
+  return Result.ok( // NOTE: Since Flow 0.98, Array.isArray() returns $ReadOnlyArray<mixed>
+  // instead of Array<mixed>.  For rationale, see
+  // https://github.com/facebook/flow/issues/7684.  In this case, we
+  // don't want to output read-only types 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 array into a normal array in
+  // Javascript is to use .slice() on it, see this benchmark:
+  // http://jsben.ch/lO6C5
+  blob.slice());
+};
+/**
+ * Given an array of Result instances, loop over them all and return:
+ * - An [index, err] tuple, indicating the (index of the) first Err instance
+ *   encountered; or
+ * - a new Ok with an array of all unwrapped Ok'ed values
+ */
+
+function all(items, blobs) {
+  var results = [];
+
+  for (var index = 0; index < items.length; ++index) {
+    var result = items[index];
+
+    if (result.type === 'ok') {
+      results.push(result.value);
+    } else {
+      var ann = result.error; // Rewrite the annotation to include the index information, and inject it into the original blob
+
+      var clone = [].concat(blobs);
+      clone.splice(index, 1, annotate(ann, ann.text ? ann.text + " (at index " + index + ")" : "index " + index)); // const errValue = [];
+      // if (index > 0) {
+      //     errValue.push('...'); // TODO: make special mark, not string!
+      // }
+      // errValue.push(
+      // );
+      // if (index < iterable.length - 1) {
+      //     errValue.push('...'); // TODO: make special mark, not string!
+      // }
+
+      return Result.err(annotate(clone));
+    }
+  }
+
+  return Result.ok(results);
+}
+/**
+ * Given a T, builds a decoder that assumes an array input and returns an
+ * Array<T>.
+ */
+
+
+function members(decoder) {
+  return function (blobs) {
+    var results = blobs.map(decoder);
+    var result = all(results, blobs);
+    return result;
+  };
+}
+/**
+ * Builds a Decoder that returns Ok for values of `Array<T>`, given a Decoder
+ * for `T`.  Err otherwise.
+ */
+
+
+export function array(decoder) {
+  return compose(poja, members(decoder));
+}
+/**
+ * Builds a Decoder that returns Ok for values of `Array<T>`, but will reject
+ * empty arrays.
+ */
+
+export function nonEmptyArray(decoder) {
+  return compose(array(decoder), predicate(function (arr) {
+    return arr.length > 0;
+  }, 'Must be non-empty array'));
+}

package/{array.js.flow → _esm/core/array.js.flow}

@@ -1,10 +1,9 @@
 // @flow strict
 
-import { annotate } from 'debrief';
-import { Err, Ok } from 'lemons/Result';
-
-import type { DecodeResult, 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, DecodeResult } from '../_types';
 
 /**
  * Like a "Plain Old JavaScript Object", but for arrays: "Plain Old JavaScript
@@ -12,9 +11,9 @@ import { compose, predicate } from './utils';
  */
 export const poja: Decoder<Array<mixed>> = (blob: mixed) => {
     if (!Array.isArray(blob)) {
-        return Err(annotate(blob, 'Must be an array'));
+        return Result.err(annotate(blob, 'Must be an array'));
     }
-    return Ok(
+    return Result.ok(
         // NOTE: Since Flow 0.98, Array.isArray() returns $ReadOnlyArray<mixed>
         // instead of Array<mixed>.  For rationale, see
         // https://github.com/facebook/flow/issues/7684.  In this case, we
@@ -24,27 +23,28 @@ export const poja: Decoder<Array<mixed>> = (blob: mixed) => {
         // The fastest way to turn a read-only array into a normal array in
         // Javascript is to use .slice() on it, see this benchmark:
         // http://jsben.ch/lO6C5
-        blob.slice()
+        blob.slice(),
     );
 };
 
 /**
- * Given an iterable of Result instances, exhaust them all and return:
+ * Given an array of Result instances, loop over them all and return:
  * - An [index, err] tuple, indicating the (index of the) first Err instance
  *   encountered; or
  * - a new Ok with an array of all unwrapped Ok'ed values
  */
 function all<T>(
-    iterable: $ReadOnlyArray<DecodeResult<T>>,
-    blobs: $ReadOnlyArray<mixed>
+    items: $ReadOnlyArray<DecodeResult<T>>,
+    blobs: $ReadOnlyArray<mixed>,
 ): DecodeResult<Array<T>> {
     const results: Array<T> = [];
-    let index = 0;
-    for (const result of iterable) {
-        try {
-            const value = result.unwrap();
-            results.push(value);
-        } catch (ann) {
+    for (let index = 0; index < items.length; ++index) {
+        const result = items[index];
+        if (result.type === 'ok') {
+            results.push(result.value);
+        } else {
+            const ann = result.error;
+
             // Rewrite the annotation to include the index information, and inject it into the original blob
             const clone = [...blobs];
             clone.splice(
@@ -52,10 +52,8 @@ function all<T>(
                 1,
                 annotate(
                     ann,
-                    ann.annotation !== undefined
-                        ? `${ann.annotation} (at index ${index})`
-                        : `index ${index}`
-                )
+                    ann.text ? `${ann.text} (at index ${index})` : `index ${index}`,
+                ),
             );
 
             // const errValue = [];
@@ -67,11 +65,10 @@ function all<T>(
             // if (index < iterable.length - 1) {
             //     errValue.push('...'); // TODO: make special mark, not string!
             // }
-            return Err(annotate(clone));
+            return Result.err(annotate(clone));
         }
-        index++;
     }
-    return Ok(results);
+    return Result.ok(results);
 }
 
 /**
@@ -101,6 +98,6 @@ export function array<T>(decoder: Decoder<T>): Decoder<Array<T>> {
 export function nonEmptyArray<T>(decoder: Decoder<T>): Decoder<Array<T>> {
     return compose(
         array(decoder),
-        predicate((arr) => arr.length > 0, 'Must be non-empty array')
+        predicate((arr) => arr.length > 0, 'Must be non-empty array'),
     );
 }

package/_esm/core/boolean.js

@@ -0,0 +1,28 @@
+import * as Result from '../result';
+import { annotate } from '../annotate';
+import { map } from './composition';
+import { number } from './number';
+
+/**
+ * Decoder that only returns Ok for boolean inputs.  Err otherwise.
+ */
+var _boolean = function _boolean(blob) {
+  return typeof blob === 'boolean' ? Result.ok(blob) : Result.err(annotate(blob, 'Must be boolean'));
+};
+/**
+ * Decoder that returns true for all truthy values, and false otherwise.  Never fails.
+ */
+
+
+export { _boolean as boolean };
+export var truthy = function truthy(blob) {
+  return Result.ok(!!blob);
+};
+/**
+ * Decoder that only returns Ok for numeric input values representing booleans.
+ * Returns their boolean representation.  Err otherwise.
+ */
+
+export var numericBoolean = map(number, function (n) {
+  return !!n;
+});

package/{boolean.js.flow → _esm/core/boolean.js.flow}

@@ -1,24 +1,25 @@
 // @flow strict
 
-import { annotate } from 'debrief';
-import { Err, Ok } from 'lemons/Result';
-
+import * as Result from '../result';
+import { annotate } from '../annotate';
+import { map } from './composition';
 import { number } from './number';
-import type { Decoder } from './types';
-import { map } from './utils';
+import type { Decoder } from '../_types';
 
 /**
  * Decoder that only returns Ok for boolean inputs.  Err otherwise.
  */
 export const boolean: Decoder<boolean> = (blob: mixed) => {
-    return typeof blob === 'boolean' ? Ok(blob) : Err(annotate(blob, 'Must be boolean'));
+    return typeof blob === 'boolean'
+        ? Result.ok(blob)
+        : Result.err(annotate(blob, 'Must be boolean'));
 };
 
 /**
  * Decoder that returns true for all truthy values, and false otherwise.  Never fails.
  */
 export const truthy: Decoder<boolean> = (blob: mixed) => {
-    return Ok(!!blob);
+    return Result.ok(!!blob);
 };
 
 /**

package/_esm/core/composition.js

@@ -0,0 +1,42 @@
+import * as Result from '../result';
+import { annotate } from '../annotate';
+
+/**
+ * Given a decoder T and a mapping function from T's to V's, returns a decoder
+ * for V's.  This is useful to change the original input data.
+ */
+export function map(decoder, mapper) {
+  return compose(decoder, function (x) {
+    try {
+      return Result.ok(mapper(x));
+    } catch (e) {
+      return Result.err(annotate(x, e instanceof Error ? e.message : String(e)));
+    }
+  });
+}
+/**
+ * Compose two decoders by passing the result of the first into the second.
+ * The second decoder may assume as its input type the output type of the first
+ * decoder (so it's not necessary to accept the typical "mixed").  This is
+ * useful for "narrowing down" the checks.  For example, if you want to write
+ * a decoder for positive numbers, you can compose it from an existing decoder
+ * for any number, and a decoder that, assuming a number, checks if it's
+ * positive.  Very often combined with the predicate() helper as the second
+ * argument.
+ */
+
+export function compose(decoder, next) {
+  return function (blob) {
+    return Result.andThen(decoder(blob), next);
+  };
+}
+/**
+ * Factory function returning a Decoder<T>, given a predicate function that
+ * accepts/rejects the input of type T.
+ */
+
+export function predicate(predicate, msg) {
+  return function (value) {
+    return predicate(value) ? Result.ok(value) : Result.err(annotate(value, msg));
+  };
+}

package/{utils.js.flow → _esm/core/composition.js.flow}

@@ -1,23 +1,8 @@
 // @flow strict
 
-import { annotate } from 'debrief';
-import { Err, Ok } from 'lemons/Result';
-
-import type { Decoder } from './types';
-
-/**
- * `x instanceof Date` checks are unreliable across stack frames (that information
- * might get lost by the JS runtime), so we'll have to reside to more runtime
- * inspection checks.
- *
- * Taken from https://stackoverflow.com/a/44198641
- */
-export const isDate = (value: mixed): boolean %checks =>
-    value !== undefined &&
-    value !== null &&
-    // $FlowFixMe[method-unbinding]
-    Object.prototype.toString.call(value) === '[object Date]' &&
-    !isNaN(value);
+import * as Result from '../result';
+import { annotate } from '../annotate';
+import type { Decoder } from '../_types';
 
 /**
  * Given a decoder T and a mapping function from T's to V's, returns a decoder
@@ -26,9 +11,9 @@ export const isDate = (value: mixed): boolean %checks =>
 export function map<T, V>(decoder: Decoder<T>, mapper: (T) => V): Decoder<V> {
     return compose(decoder, (x) => {
         try {
-            return Ok(mapper(x));
+            return Result.ok(mapper(x));
         } catch (e) {
-            return Err(annotate(x, e instanceof Error ? e.message : String(e)));
+            return Result.err(annotate(x, e instanceof Error ? e.message : String(e)));
         }
     });
 }
@@ -44,7 +29,7 @@ export function map<T, V>(decoder: Decoder<T>, mapper: (T) => V): Decoder<V> {
  * argument.
  */
 export function compose<T, V>(decoder: Decoder<T>, next: Decoder<V, T>): Decoder<V> {
-    return (blob: mixed) => decoder(blob).andThen(next);
+    return (blob: mixed) => Result.andThen(decoder(blob), next);
 }
 
 /**
@@ -53,6 +38,6 @@ export function compose<T, V>(decoder: Decoder<T>, next: Decoder<V, T>): Decoder
  */
 export function predicate<T>(predicate: (T) => boolean, msg: string): Decoder<T, T> {
     return (value: T) => {
-        return predicate(value) ? Ok(value) : Err(annotate(value, msg));
+        return predicate(value) ? Result.ok(value) : Result.err(annotate(value, msg));
     };
 }

package/_esm/core/constants.js

@@ -0,0 +1,46 @@
+import * as Result from '../result';
+import { annotate } from '../annotate';
+
+/**
+ * Decoder that only returns Ok for `null` inputs.  Err otherwise.
+ */
+export var null_ = function null_(blob) {
+  return blob === null ? Result.ok(blob) : Result.err(annotate(blob, 'Must be null'));
+};
+/**
+ * Decoder that only returns Ok for `undefined` inputs.  Err otherwise.
+ */
+
+export var undefined_ = function undefined_(blob) {
+  return blob === undefined ? Result.ok(blob) : Result.err(annotate(blob, 'Must be undefined'));
+};
+/**
+ * Decoder that only returns Ok for the given value constant.  Err otherwise.
+ */
+
+export function constant(value) {
+  return function (blob) {
+    return blob === value ? Result.ok(value) : Result.err(annotate(blob, "Must be constant " + String(value)));
+  };
+}
+/**
+ * Decoder that always returns Ok for the given hardcoded value, no matter what the input.
+ */
+
+export function hardcoded(value) {
+  return function () {
+    return Result.ok(value);
+  };
+}
+/**
+ * Decoder that always returns Ok for the given hardcoded value, no matter what the input.
+ */
+
+export var unknown = function unknown(blob) {
+  return Result.ok(blob);
+};
+/**
+ * Alias of unknown.
+ */
+
+export var mixed = unknown;

package/{constants.js.flow → _esm/core/constants.js.flow}

@@ -1,21 +1,22 @@
 // @flow strict
 
-import { annotate } from 'debrief';
-import { Err, Ok } from 'lemons/Result';
-
-import type { Decoder, Scalar } from './types';
+import * as Result from '../result';
+import { annotate } from '../annotate';
+import type { Decoder, Scalar } from '../_types';
 
 /**
  * Decoder that only returns Ok for `null` inputs.  Err otherwise.
  */
 export const null_: Decoder<null> = (blob: mixed) =>
-    blob === null ? Ok(blob) : Err(annotate(blob, 'Must be null'));
+    blob === null ? Result.ok(blob) : Result.err(annotate(blob, 'Must be null'));
 
 /**
  * Decoder that only returns Ok for `undefined` inputs.  Err otherwise.
  */
 export const undefined_: Decoder<void> = (blob: mixed) =>
-    blob === undefined ? Ok(blob) : Err(annotate(blob, 'Must be undefined'));
+    blob === undefined
+        ? Result.ok(blob)
+        : Result.err(annotate(blob, 'Must be undefined'));
 
 /**
  * Decoder that only returns Ok for the given value constant.  Err otherwise.
@@ -23,23 +24,23 @@ export const undefined_: Decoder<void> = (blob: mixed) =>
 export function constant<T: Scalar>(value: T): Decoder<T> {
     return (blob: mixed) =>
         blob === value
-            ? Ok(value)
-            : Err(annotate(blob, `Must be constant ${String(value)}`));
+            ? Result.ok(value)
+            : Result.err(annotate(blob, `Must be constant ${String(value)}`));
 }
 
 /**
  * Decoder that always returns Ok for the given hardcoded value, no matter what the input.
  */
 export function hardcoded<T>(value: T): Decoder<T> {
-    return (_: mixed) => Ok(value);
+    return () => Result.ok(value);
 }
 
 /**
  * Decoder that always returns Ok for the given hardcoded value, no matter what the input.
  */
-export const mixed: Decoder<mixed> = (blob: mixed) => Ok((blob: mixed));
+export const unknown: Decoder<mixed> = (blob: mixed) => Result.ok(blob);
 
 /**
- * Alias of mixed.
+ * Alias of unknown.
  */
-export const unknown = mixed;
+export const mixed: Decoder<mixed> = unknown;

package/_esm/core/date.js

@@ -0,0 +1,28 @@
+import * as Result from '../result';
+import { annotate } from '../annotate';
+import { isDate } from '../_utils';
+import { map } from './composition';
+import { regex } from './string';
+// Only matches the shape.  This "over-matches" some values that still aren't
+// valid dates (like 9999-99-99), but those will be caught by JS Date's
+// internal validations
+var iso8601_re = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:[.]\d+)?(?:Z|[+-]\d{2}:?\d{2})$/;
+export var date = function date(value) {
+  return isDate(value) ? Result.ok(value) : Result.err(annotate(value, 'Must be a Date'));
+};
+/**
+ * Decoder that only returns Ok for strings that are valid ISO8601 date
+ * strings.  Err otherwise.
+ */
+
+export var iso8601 = map( // Input itself needs to match the ISO8601 regex...
+regex(iso8601_re, 'Must be ISO8601 format'), // Make sure it is a _valid_ date
+function (value) {
+  var date = new Date(value);
+
+  if (isNaN(date.getTime())) {
+    throw new Error('Must be valid date/time value');
+  }
+
+  return date;
+});

package/{date.js.flow → _esm/core/date.js.flow}

@@ -1,11 +1,11 @@
 // @flow strict
 
-import { annotate } from 'debrief';
-import { Err, Ok } from 'lemons/Result';
-
+import * as Result from '../result';
+import { annotate } from '../annotate';
+import { isDate } from '../_utils';
+import { map } from './composition';
 import { regex } from './string';
-import type { Decoder } from './types';
-import { isDate, map } from './utils';
+import type { Decoder } from '../_types';
 
 // $FlowFixMe[unclear-type] (not really an issue) - deliberate casting
 type cast = any;
@@ -17,7 +17,9 @@ const iso8601_re =
     /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:[.]\d+)?(?:Z|[+-]\d{2}:?\d{2})$/;
 
 export const date: Decoder<Date> = (value: mixed) =>
-    isDate(value) ? Ok(((value: cast): Date)) : Err(annotate(value, 'Must be a Date'));
+    isDate(value)
+        ? Result.ok(((value: cast): Date))
+        : Result.err(annotate(value, 'Must be a Date'));
 
 /**
  * Decoder that only returns Ok for strings that are valid ISO8601 date
@@ -34,5 +36,5 @@ export const iso8601: Decoder<Date> = map(
             throw new Error('Must be valid date/time value');
         }
         return date;
-    }
+    },
 );

package/{describe.js → _esm/core/describe.js}

@@ -1,11 +1,5 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.describe = describe;
-
-var _debrief = require("debrief");
+import * as Result from '../result';
+import { annotate } from '../annotate';
 
 /**
  * Wrap another decoder, and override the error message in case it fails. This
@@ -13,10 +7,10 @@ var _debrief = require("debrief");
  * use language in those error messages that can be relayed to end users (for
  * example to show in form errors).
  */
-function describe(decoder, message) {
+export function describe(decoder, message) {
   return function (blob) {
-    return decoder(blob).mapError(function (err) {
-      return (0, _debrief.annotate)(err, message);
+    return Result.mapError(decoder(blob), function (err) {
+      return annotate(err, message);
     });
   };
 }

package/{describe.js.flow → _esm/core/describe.js.flow}

@@ -1,8 +1,8 @@
 // @flow strict
 
-import { annotate } from 'debrief';
-
-import type { Decoder } from './types';
+import * as Result from '../result';
+import { annotate } from '../annotate';
+import type { Decoder } from '../_types';
 
 /**
  * Wrap another decoder, and override the error message in case it fails. This
@@ -12,6 +12,6 @@ import type { Decoder } from './types';
  */
 export function describe<T>(decoder: Decoder<T>, message: string): Decoder<T> {
     return (blob: mixed) => {
-        return decoder(blob).mapError((err) => annotate(err, message));
+        return Result.mapError(decoder(blob), (err) => annotate(err, message));
     };
 }

package/{dispatch.js → _esm/core/dispatch.js}

@@ -1,15 +1,6 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.dispatch = dispatch;
-
-var _either = require("./either");
-
-var _object2 = require("./object");
-
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+import * as Result from '../result';
+import { object } from './object';
+import { oneOf } from './either';
 
 /**
  * Dispatches to one of several given decoders, based on the value found at
@@ -46,10 +37,12 @@ function _defineProperty(obj, key, value) { if (key in obj) { Object.definePrope
  *
  * Also, the error messages will be less ambiguous using `dispatch()`.
  */
-function dispatch(field, mapping) {
-  var base = (0, _object2.object)(_defineProperty({}, field, (0, _either.oneOf)(Object.keys(mapping))));
+export function dispatch(field, mapping) {
+  var _object;
+
+  var base = object((_object = {}, _object[field] = oneOf(Object.keys(mapping)), _object));
   return function (blob) {
-    return base(blob).andThen(function (baseObj) {
+    return Result.andThen(base(blob), function (baseObj) {
       var decoderName = baseObj[field];
       var decoder = mapping[decoderName];
       return decoder(blob);

package/{dispatch.js.flow → _esm/core/dispatch.js.flow}

@@ -1,8 +1,9 @@
 // @flow strict
 
-import { oneOf } from './either';
+import * as Result from '../result';
 import { object } from './object';
-import type { $DecoderType, Decoder } from './types';
+import { oneOf } from './either';
+import type { Decoder, DecoderType } from '../_types';
 
 // $FlowFixMe[unclear-type] (not really an issue) - deliberate use of `any` - not sure how we should get rid of this
 type anything = any;
@@ -44,11 +45,11 @@ type anything = any;
  */
 export function dispatch<O: { +[field: string]: Decoder<anything>, ... }>(
     field: string,
-    mapping: O
-): Decoder<$Values<$ObjMap<O, $DecoderType>>> {
+    mapping: O,
+): Decoder<$Values<$ObjMap<O, DecoderType>>> {
     const base = object({ [field]: oneOf(Object.keys(mapping)) });
     return (blob: mixed) => {
-        return base(blob).andThen((baseObj) => {
+        return Result.andThen(base(blob), (baseObj) => {
             const decoderName = baseObj[field];
             const decoder = mapping[decoderName];
             return decoder(blob);