decoders 2.0.0-beta1 → 2.0.0-beta13

package/cjs/stdlib/array.js.flow

@@ -1,103 +0,0 @@
-// @flow strict
-
-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
- * Array" ^_^
- */
-export const poja: Decoder<Array<mixed>> = (blob: mixed) => {
-    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<T>(
-    items: $ReadOnlyArray<DecodeResult<T>>,
-    blobs: $ReadOnlyArray<mixed>,
-): DecodeResult<Array<T>> {
-    const results: Array<T> = [];
-    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(
-                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<T>(decoder: Decoder<T>): Decoder<Array<T>, Array<mixed>> {
-    return (blobs: $ReadOnlyArray<mixed>) => {
-        const results = blobs.map(decoder);
-        const 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<T>(decoder: Decoder<T>): Decoder<Array<T>> {
-    return compose(poja, members(decoder));
-}
-
-/**
- * Builds a Decoder that returns Ok for values of `Array<T>`, but will reject
- * 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'),
-    );
-}

package/cjs/stdlib/boolean.js

@@ -1,44 +0,0 @@
-"use strict";
-
-exports.__esModule = true;
-exports.truthy = exports.numericBoolean = exports["boolean"] = void 0;
-
-var Result = _interopRequireWildcard(require("../result"));
-
-var _annotate = require("../annotate");
-
-var _composition = require("./composition");
-
-var _number = require("./number");
-
-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 only returns Ok for boolean inputs.  Err otherwise.
- */
-var _boolean = function _boolean(blob) {
-  return typeof blob === 'boolean' ? Result.ok(blob) : Result.err((0, _annotate.annotate)(blob, 'Must be boolean'));
-};
-/**
- * Decoder that returns true for all truthy values, and false otherwise.  Never fails.
- */
-
-
-exports["boolean"] = _boolean;
-
-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.
- */
-
-
-exports.truthy = truthy;
-var numericBoolean = (0, _composition.map)(_number.number, function (n) {
-  return !!n;
-});
-exports.numericBoolean = numericBoolean;

package/cjs/stdlib/boolean.js.flow

@@ -1,29 +0,0 @@
-// @flow strict
-
-import * as Result from '../result';
-import { annotate } from '../annotate';
-import { map } from './composition';
-import { number } from './number';
-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'
-        ? 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 Result.ok(!!blob);
-};
-
-/**
- * Decoder that only returns Ok for numeric input values representing booleans.
- * Returns their boolean representation.  Err otherwise.
- */
-export const numericBoolean: Decoder<boolean> = map(number, (n) => !!n);

package/cjs/stdlib/composition.js

@@ -1,56 +0,0 @@
-"use strict";
-
-exports.__esModule = true;
-exports.compose = compose;
-exports.map = map;
-exports.predicate = predicate;
-
-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; }
-
-/**
- * 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.
- */
-function map(decoder, mapper) {
-  return compose(decoder, function (x) {
-    try {
-      return Result.ok(mapper(x));
-    } catch (e) {
-      return Result.err((0, _annotate.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.
- */
-
-
-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.
- */
-
-
-function predicate(predicate, msg) {
-  return function (value) {
-    return predicate(value) ? Result.ok(value) : Result.err((0, _annotate.annotate)(value, msg));
-  };
-}

package/cjs/stdlib/composition.js.flow

@@ -1,43 +0,0 @@
-// @flow strict
-
-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
- * for V's.  This is useful to change the original input data.
- */
-export function map<T, V>(decoder: Decoder<T>, mapper: (T) => V): Decoder<V> {
-    return compose(decoder, (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<T, V>(decoder: Decoder<T>, next: Decoder<V, T>): Decoder<V> {
-    return (blob: mixed) => 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<T>(predicate: (T) => boolean, msg: string): Decoder<T, T> {
-    return (value: T) => {
-        return predicate(value) ? Result.ok(value) : Result.err(annotate(value, msg));
-    };
-}

package/cjs/stdlib/constants.js

@@ -1,69 +0,0 @@
-"use strict";
-
-exports.__esModule = true;
-exports.constant = constant;
-exports.hardcoded = hardcoded;
-exports.unknown = exports.undefined_ = exports.null_ = exports.mixed = void 0;
-
-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 only returns Ok for `null` inputs.  Err otherwise.
- */
-var null_ = function null_(blob) {
-  return blob === null ? Result.ok(blob) : Result.err((0, _annotate.annotate)(blob, 'Must be null'));
-};
-/**
- * Decoder that only returns Ok for `undefined` inputs.  Err otherwise.
- */
-
-
-exports.null_ = null_;
-
-var undefined_ = function undefined_(blob) {
-  return blob === undefined ? Result.ok(blob) : Result.err((0, _annotate.annotate)(blob, 'Must be undefined'));
-};
-/**
- * Decoder that only returns Ok for the given value constant.  Err otherwise.
- */
-
-
-exports.undefined_ = undefined_;
-
-function constant(value) {
-  return function (blob) {
-    return blob === value ? Result.ok(value) : Result.err((0, _annotate.annotate)(blob, "Must be constant " + String(value)));
-  };
-}
-/**
- * Decoder that always returns Ok for the given hardcoded value, no matter what the input.
- */
-
-
-function hardcoded(value) {
-  return function () {
-    return Result.ok(value);
-  };
-}
-/**
- * Decoder that always returns Ok for the given hardcoded value, no matter what the input.
- */
-
-
-var unknown = function unknown(blob) {
-  return Result.ok(blob);
-};
-/**
- * Alias of unknown.
- */
-
-
-exports.unknown = unknown;
-var mixed = unknown;
-exports.mixed = mixed;

package/cjs/stdlib/constants.js.flow

@@ -1,46 +0,0 @@
-// @flow strict
-
-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 ? 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
-        ? 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<T: Scalar>(value: T): Decoder<T> {
-    return (blob: mixed) =>
-        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<T>(value: T): Decoder<T> {
-    return () => Result.ok(value);
-}
-
-/**
- * Decoder that always returns Ok for the given hardcoded value, no matter what the input.
- */
-export const unknown: Decoder<mixed> = (blob: mixed) => Result.ok(blob);
-
-/**
- * Alias of unknown.
- */
-export const mixed: Decoder<mixed> = unknown;

package/cjs/stdlib/date.js

@@ -1,46 +0,0 @@
-"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/cjs/stdlib/date.js.flow

@@ -1,40 +0,0 @@
-// @flow strict
-
-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';
-
-// $FlowFixMe[unclear-type] (not really an issue) - deliberate casting
-type cast = any;
-
-// 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
-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)
-        ? 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
- * strings.  Err otherwise.
- */
-export const iso8601: Decoder<Date> = map(
-    // Input itself needs to match the ISO8601 regex...
-    regex(iso8601_re, 'Must be ISO8601 format'),
-
-    // Make sure it is a _valid_ date
-    (value: string) => {
-        const date = new Date(value);
-        if (isNaN(date.getTime())) {
-            throw new Error('Must be valid date/time value');
-        }
-        return date;
-    },
-);

package/cjs/stdlib/describe.js

@@ -1,26 +0,0 @@
-"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/cjs/stdlib/describe.js.flow

@@ -1,17 +0,0 @@
-// @flow strict
-
-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
- * 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).
- */
-export function describe<T>(decoder: Decoder<T>, message: string): Decoder<T> {
-    return (blob: mixed) => {
-        return Result.mapError(decoder(blob), (err) => annotate(err, message));
-    };
-}

package/cjs/stdlib/dispatch.js

@@ -1,62 +0,0 @@
-"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/cjs/stdlib/dispatch.js.flow

@@ -1,58 +0,0 @@
-// @flow strict
-
-import * as Result from '../result';
-import { object } from './object';
-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;
-
-/**
- * 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()`.
- */
-export function dispatch<O: { +[field: string]: Decoder<anything>, ... }>(
-    field: string,
-    mapping: O,
-): Decoder<$Values<$ObjMap<O, DecoderType>>> {
-    const base = object({ [field]: oneOf(Object.keys(mapping)) });
-    return (blob: mixed) => {
-        return Result.andThen(base(blob), (baseObj) => {
-            const decoderName = baseObj[field];
-            const decoder = mapping[decoderName];
-            return decoder(blob);
-        });
-    };
-}