decoders 1.25.4 → 2.0.0-beta1

package/{constants.js.flow → cjs/stdlib/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/cjs/stdlib/date.js

@@ -0,0 +1,46 @@
+"use strict";
+
+exports.__esModule = true;
+exports.iso8601 = exports.date = void 0;
+
+var Result = _interopRequireWildcard(require("../result"));
+
+var _annotate = require("../annotate");
+
+var _utils = require("../_utils");
+
+var _composition = require("./composition");
+
+var _string = require("./string");
+
+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; }
+
+// 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})$/;
+
+var date = function date(value) {
+  return (0, _utils.isDate)(value) ? Result.ok(value) : Result.err((0, _annotate.annotate)(value, 'Must be a Date'));
+};
+/**
+ * Decoder that only returns Ok for strings that are valid ISO8601 date
+ * strings.  Err otherwise.
+ */
+
+
+exports.date = date;
+var iso8601 = (0, _composition.map)( // Input itself needs to match the ISO8601 regex...
+(0, _string.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;
+});
+exports.iso8601 = iso8601;

package/{date.js.flow → cjs/stdlib/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/cjs/stdlib/describe.js

@@ -0,0 +1,26 @@
+"use strict";
+
+exports.__esModule = true;
+exports.describe = describe;
+
+var Result = _interopRequireWildcard(require("../result"));
+
+var _annotate = require("../annotate");
+
+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; }
+
+/**
+ * Wrap another decoder, and override the error message in case it fails. This
+ * is useful to "simplify" otherwise potentially complex error messages, or to
+ * use language in those error messages that can be relayed to end users (for
+ * example to show in form errors).
+ */
+function describe(decoder, message) {
+  return function (blob) {
+    return Result.mapError(decoder(blob), function (err) {
+      return (0, _annotate.annotate)(err, message);
+    });
+  };
+}

package/{describe.js.flow → cjs/stdlib/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/cjs/stdlib/dispatch.js

@@ -0,0 +1,62 @@
+"use strict";
+
+exports.__esModule = true;
+exports.dispatch = dispatch;
+
+var Result = _interopRequireWildcard(require("../result"));
+
+var _object2 = require("./object");
+
+var _either = require("./either");
+
+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; }
+
+/**
+ * Dispatches to one of several given decoders, based on the value found at
+ * runtime in the given field.  For example, suppose you have these decoders:
+ *
+ *     const rectangle = object({
+ *         type: constant('rect'),
+ *         x: number,
+ *         y: number,
+ *         width: number,
+ *         height: number,
+ *     });
+ *
+ *     const circle = object({
+ *         type: constant('circle'),
+ *         cx: number,
+ *         cy: number,
+ *         r: number,
+ *      });
+ *
+ * Then these two decoders are equivalent:
+ *
+ *     const shape = either(rectangle, circle)
+ *     const shape = dispatch('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.
+ *
+ * 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()`.
+ */
+function dispatch(field, mapping) {
+  var _object;
+
+  var base = (0, _object2.object)((_object = {}, _object[field] = (0, _either.oneOf)(Object.keys(mapping)), _object));
+  return function (blob) {
+    return Result.andThen(base(blob), function (baseObj) {
+      var decoderName = baseObj[field];
+      var decoder = mapping[decoderName];
+      return decoder(blob);
+    });
+  };
+}

package/{dispatch.js.flow → cjs/stdlib/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);

package/cjs/stdlib/either.js

@@ -0,0 +1,117 @@
+"use strict";
+
+exports.__esModule = true;
+exports.either = either;
+exports.either3 = either3;
+exports.either4 = either4;
+exports.either5 = either5;
+exports.either6 = either6;
+exports.either7 = either7;
+exports.either8 = either8;
+exports.either9 = either9;
+exports.oneOf = oneOf;
+
+var Result = _interopRequireWildcard(require("../result"));
+
+var _annotate = require("../annotate");
+
+var _utils = require("../_utils");
+
+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; }
+
+/**
+ * Indents and adds a dash in front of this (potentially multiline) string.
+ */
+function itemize(s) {
+  return '-' + (0, _utils.indent)(s).substring(1);
+}
+/**
+ * Nests another error as an item under a new-to-be-created "Either error". If
+ * the given subitem already is an "Either error" of itself, don't indent, but
+ * just "inject" its items at the same error level, for nicely flattened either
+ * expressions.
+ *
+ * Avoids:
+ *
+ *     Either:
+ *     - Either:
+ *       - Must be P
+ *       - Either:
+ *         - Must be Q
+ *         - Must be R
+ *     - Must be S
+ *
+ * And "flattens" these to:
+ *
+ *     Either:
+ *     - Must be P
+ *     - Must be Q
+ *     - Must be R
+ *     - Must be S
+ *
+ */
+
+
+function nest(errText) {
+  var EITHER_PREFIX = 'Either:\n';
+  return errText.startsWith(EITHER_PREFIX) ? errText.substr(EITHER_PREFIX.length) : itemize(errText);
+}
+
+function either(d1, d2) {
+  return function (blob) {
+    return Result.orElse(d1(blob), function (err1) {
+      return Result.orElse(d2(blob), function (err2) {
+        var serr1 = (0, _utils.summarize)(err1).join('\n');
+        var serr2 = (0, _utils.summarize)(err2).join('\n');
+        var text = ['Either:', nest(serr1), nest(serr2)].join('\n');
+        return Result.err((0, _annotate.annotate)(blob, text));
+      });
+    });
+  };
+}
+
+function either3(d1, d2, d3) {
+  return either(d1, either(d2, d3));
+}
+
+function either4(d1, d2, d3, d4) {
+  return either(d1, either3(d2, d3, d4));
+}
+
+function either5(d1, d2, d3, d4, d5) {
+  return either(d1, either4(d2, d3, d4, d5));
+}
+
+function either6(d1, d2, d3, d4, d5, d6) {
+  return either(d1, either5(d2, d3, d4, d5, d6));
+}
+
+function either7(d1, d2, d3, d4, d5, d6, d7) {
+  return either(d1, either6(d2, d3, d4, d5, d6, d7));
+}
+
+function either8(d1, d2, d3, d4, d5, d6, d7, d8) {
+  return either(d1, either7(d2, d3, d4, d5, d6, d7, d8));
+}
+
+function either9(d1, d2, d3, d4, d5, d6, d7, d8, d9) {
+  return either(d1, either8(d2, d3, d4, d5, d6, d7, d8, d9));
+}
+
+function oneOf(constants) {
+  return function (blob) {
+    var winner = constants.find(function (c) {
+      return c === blob;
+    });
+
+    if (winner !== undefined) {
+      return Result.ok(winner);
+    }
+
+    return Result.err((0, _annotate.annotate)(blob, "Must be one of " + constants.map(function (value) {
+      return JSON.stringify(value);
+    }).join(', ')));
+  };
+}

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

@@ -1,45 +1,65 @@
 // @flow strict
 
-import { annotate, indent } from 'debrief';
-import { summarize } from 'debrief';
-import { Err, Ok } from 'lemons/Result';
-
-import type { Decoder, Scalar } from './types';
+import * as Result from '../result';
+import { annotate } from '../annotate';
+import { indent, summarize } from '../_utils';
+import type { Decoder, Scalar } from '../_types';
 
 /**
  * Indents and adds a dash in front of this (potentially multiline) string.
  */
-// istanbul ignore next
-function itemize(s: string = ''): string {
+function itemize(s: string): string {
     return '-' + indent(s).substring(1);
 }
 
+/**
+ * Nests another error as an item under a new-to-be-created "Either error". If
+ * the given subitem already is an "Either error" of itself, don't indent, but
+ * just "inject" its items at the same error level, for nicely flattened either
+ * expressions.
+ *
+ * Avoids:
+ *
+ *     Either:
+ *     - Either:
+ *       - Must be P
+ *       - Either:
+ *         - Must be Q
+ *         - Must be R
+ *     - Must be S
+ *
+ * And "flattens" these to:
+ *
+ *     Either:
+ *     - Must be P
+ *     - Must be Q
+ *     - Must be R
+ *     - Must be S
+ *
+ */
+function nest(errText: string): string {
+    const EITHER_PREFIX = 'Either:\n';
+    return errText.startsWith(EITHER_PREFIX)
+        ? errText.substr(EITHER_PREFIX.length)
+        : itemize(errText);
+}
+
 export function either<T1, T2>(d1: Decoder<T1>, d2: Decoder<T2>): Decoder<T1 | T2> {
     return (blob: mixed) =>
-        d1(blob).dispatch(
-            (value1) => Ok(value1),
-            (err1) =>
-                d2(blob).dispatch(
-                    (value2) => Ok(value2),
-                    (err2) =>
-                        Err(
-                            annotate(
-                                blob,
-                                [
-                                    'Either:',
-                                    itemize(summarize(err1).join('\n')),
-                                    itemize(summarize(err2).join('\n')),
-                                ].join('\n')
-                            )
-                        )
-                )
+        Result.orElse(d1(blob), (err1) =>
+            Result.orElse(d2(blob), (err2) => {
+                const serr1 = summarize(err1).join('\n');
+                const serr2 = summarize(err2).join('\n');
+                const text = ['Either:', nest(serr1), nest(serr2)].join('\n');
+                return Result.err(annotate(blob, text));
+            }),
         );
 }
 
 export function either3<T1, T2, T3>(
     d1: Decoder<T1>,
     d2: Decoder<T2>,
-    d3: Decoder<T3>
+    d3: Decoder<T3>,
 ): Decoder<T1 | T2 | T3> {
     return either(d1, either(d2, d3));
 }
@@ -48,7 +68,7 @@ export function either4<T1, T2, T3, T4>(
     d1: Decoder<T1>,
     d2: Decoder<T2>,
     d3: Decoder<T3>,
-    d4: Decoder<T4>
+    d4: Decoder<T4>,
 ): Decoder<T1 | T2 | T3 | T4> {
     return either(d1, either3(d2, d3, d4));
 }
@@ -58,7 +78,7 @@ export function either5<T1, T2, T3, T4, T5>(
     d2: Decoder<T2>,
     d3: Decoder<T3>,
     d4: Decoder<T4>,
-    d5: Decoder<T5>
+    d5: Decoder<T5>,
 ): Decoder<T1 | T2 | T3 | T4 | T5> {
     return either(d1, either4(d2, d3, d4, d5));
 }
@@ -69,7 +89,7 @@ export function either6<T1, T2, T3, T4, T5, T6>(
     d3: Decoder<T3>,
     d4: Decoder<T4>,
     d5: Decoder<T5>,
-    d6: Decoder<T6>
+    d6: Decoder<T6>,
 ): Decoder<T1 | T2 | T3 | T4 | T5 | T6> {
     return either(d1, either5(d2, d3, d4, d5, d6));
 }
@@ -81,7 +101,7 @@ export function either7<T1, T2, T3, T4, T5, T6, T7>(
     d4: Decoder<T4>,
     d5: Decoder<T5>,
     d6: Decoder<T6>,
-    d7: Decoder<T7>
+    d7: Decoder<T7>,
 ): Decoder<T1 | T2 | T3 | T4 | T5 | T6 | T7> {
     return either(d1, either6(d2, d3, d4, d5, d6, d7));
 }
@@ -94,7 +114,7 @@ export function either8<T1, T2, T3, T4, T5, T6, T7, T8>(
     d5: Decoder<T5>,
     d6: Decoder<T6>,
     d7: Decoder<T7>,
-    d8: Decoder<T8>
+    d8: Decoder<T8>,
 ): Decoder<T1 | T2 | T3 | T4 | T5 | T6 | T7 | T8> {
     return either(d1, either7(d2, d3, d4, d5, d6, d7, d8));
 }
@@ -108,7 +128,7 @@ export function either9<T1, T2, T3, T4, T5, T6, T7, T8, T9>(
     d6: Decoder<T6>,
     d7: Decoder<T7>,
     d8: Decoder<T8>,
-    d9: Decoder<T9>
+    d9: Decoder<T9>,
 ): Decoder<T1 | T2 | T3 | T4 | T5 | T6 | T7 | T8 | T9> {
     return either(d1, either8(d2, d3, d4, d5, d6, d7, d8, d9));
 }
@@ -117,15 +137,15 @@ export function oneOf<T: Scalar>(constants: $ReadOnlyArray<T>): Decoder<T> {
     return (blob: mixed) => {
         const winner = constants.find((c) => c === blob);
         if (winner !== undefined) {
-            return Ok(winner);
+            return Result.ok(winner);
         }
-        return Err(
+        return Result.err(
             annotate(
                 blob,
                 `Must be one of ${constants
                     .map((value) => JSON.stringify(value))
-                    .join(', ')}`
-            )
+                    .join(', ')}`,
+            ),
         );
     };
 }

package/cjs/stdlib/fail.js

@@ -0,0 +1,21 @@
+"use strict";
+
+exports.__esModule = true;
+exports.fail = fail;
+
+var Result = _interopRequireWildcard(require("../result"));
+
+var _annotate = require("../annotate");
+
+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; }
+
+/**
+ * Decoder that always fails with the given error message, no matter what the input.
+ */
+function fail(msg) {
+  return function (blob) {
+    return Result.err((0, _annotate.annotate)(blob, msg));
+  };
+}

package/cjs/stdlib/fail.js.flow

@@ -0,0 +1,12 @@
+// @flow strict
+
+import * as Result from '../result';
+import { annotate } from '../annotate';
+import type { Decoder } from '../_types';
+
+/**
+ * Decoder that always fails with the given error message, no matter what the input.
+ */
+export function fail(msg: string): Decoder<empty> {
+    return (blob: mixed) => Result.err(annotate(blob, msg));
+}

package/cjs/stdlib/instanceOf.js

@@ -0,0 +1,19 @@
+"use strict";
+
+exports.__esModule = true;
+exports.instanceOf = instanceOf;
+
+var Result = _interopRequireWildcard(require("../result"));
+
+var _annotate = require("../annotate");
+
+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 instanceOf(klass) {
+  return function (blob) {
+    return blob instanceof klass ? Result.ok(blob) : Result.err((0, _annotate.annotate)(blob, "Must be " + // $FlowFixMe[incompatible-use] - klass.name is fine?
+    klass.name + " instance"));
+  };
+}

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

@@ -1,21 +1,20 @@
 // @flow strict
 
-import { annotate } from 'debrief';
-import { Err, Ok } from 'lemons/Result';
-
-import type { Decoder } from './types';
+import * as Result from '../result';
+import { annotate } from '../annotate';
+import type { Decoder } from '../_types';
 
 export function instanceOf<T>(klass: Class<T>): Decoder<T> {
     return (blob: mixed) =>
         blob instanceof klass
-            ? Ok(blob)
-            : Err(
+            ? Result.ok(blob)
+            : Result.err(
                   annotate(
                       blob,
                       `Must be ${
                           // $FlowFixMe[incompatible-use] - klass.name is fine?
                           klass.name
-                      } instance`
-                  )
+                      } instance`,
+                  ),
               );
 }