decoders 2.0.0-beta9 → 2.0.0

package/core/dispatch.js.flow

@@ -1,59 +0,0 @@
-// @flow strict
-
-import { andThen } from '../result';
-import { object } from './object';
-import { oneOf } from './either';
-import { prep } from './composition';
-import type { _Any } from '../_utils';
-import type { Decoder, DecoderType } from '../_types';
-
-/**
- * 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 = taggedUnion('type', { rectangle, circle })
- *
- * Will be of type Decoder<Rectangle | Circle>.
- *
- * But `taggedUnion` 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 `taggedUnion()`.
- */
-export function taggedUnion<O: { +[field: string]: Decoder<_Any>, ... }>(
-    field: string,
-    mapping: O,
-): Decoder<$Values<$ObjMap<O, DecoderType>>> {
-    const base = object({
-        [field]: prep(String, oneOf(Object.keys(mapping))),
-    });
-    return (blob: mixed) => {
-        return andThen(base(blob), (baseObj) => {
-            const decoderName = baseObj[field];
-            const decoder = mapping[decoderName];
-            return decoder(blob);
-        });
-    };
-}

package/core/dispatch.mjs

@@ -1,52 +0,0 @@
-import { andThen } from '../result.mjs';
-import { object } from './object.mjs';
-import { oneOf } from './either.mjs';
-import { prep } from './composition.mjs';
-
-/**
- * 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 = taggedUnion('type', { rectangle, circle })
- *
- * Will be of type Decoder<Rectangle | Circle>.
- *
- * But `taggedUnion` 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 `taggedUnion()`.
- */
-export function taggedUnion(field, mapping) {
-  var _object;
-
-  var base = object((_object = {}, _object[field] = prep(String, oneOf(Object.keys(mapping))), _object));
-  return function (blob) {
-    return andThen(base(blob), function (baseObj) {
-      var decoderName = baseObj[field];
-      var decoder = mapping[decoderName];
-      return decoder(blob);
-    });
-  };
-}

package/core/either.d.ts

@@ -1,66 +0,0 @@
-import { Decoder, Scalar } from '../_types';
-
-export type DecoderTypes<T> = T extends ReadonlyArray<Decoder<infer U>> ? U : never;
-
-export function either<T extends ReadonlyArray<Decoder<any>>>(
-    ...args: T
-): Decoder<DecoderTypes<T>>;
-// export function either<T1, T2>(d1: Decoder<T1>, d2: Decoder<T2>): Decoder<T1 | T2>;
-// export function either2<T1, T2>(d1: Decoder<T1>, d2: Decoder<T2>): Decoder<T1 | T2>;
-// export function either3<T1, T2, T3>(
-//     d1: Decoder<T1>,
-//     d2: Decoder<T2>,
-//     d3: Decoder<T3>,
-// ): Decoder<T1 | T2 | T3>;
-// export function either4<T1, T2, T3, T4>(
-//     d1: Decoder<T1>,
-//     d2: Decoder<T2>,
-//     d3: Decoder<T3>,
-//     d4: Decoder<T4>,
-// ): Decoder<T1 | T2 | T3 | T4>;
-// export function either5<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 either6<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 either7<T1, T2, T3, T4, T5, T6, T7>(
-//     d1: Decoder<T1>,
-//     d2: Decoder<T2>,
-//     d3: Decoder<T3>,
-//     d4: Decoder<T4>,
-//     d5: Decoder<T5>,
-//     d6: Decoder<T6>,
-//     d7: Decoder<T7>,
-// ): Decoder<T1 | T2 | T3 | T4 | T5 | T6 | T7>;
-// export function either8<T1, T2, T3, T4, T5, T6, T7, T8>(
-//     d1: Decoder<T1>,
-//     d2: Decoder<T2>,
-//     d3: Decoder<T3>,
-//     d4: Decoder<T4>,
-//     d5: Decoder<T5>,
-//     d6: Decoder<T6>,
-//     d7: Decoder<T7>,
-//     d8: Decoder<T8>,
-// ): Decoder<T1 | T2 | T3 | T4 | T5 | T6 | T7 | T8>;
-// export function either9<T1, T2, T3, T4, T5, T6, T7, T8, T9>(
-//     d1: Decoder<T1>,
-//     d2: Decoder<T2>,
-//     d3: Decoder<T3>,
-//     d4: Decoder<T4>,
-//     d5: Decoder<T5>,
-//     d6: Decoder<T6>,
-//     d7: Decoder<T7>,
-//     d8: Decoder<T8>,
-//     d9: Decoder<T9>,
-// ): Decoder<T1 | T2 | T3 | T4 | T5 | T6 | T7 | T8 | T9>;
-export function oneOf<T extends Scalar>(constants: readonly T[]): Decoder<T>;

package/core/either.js

@@ -1,101 +0,0 @@
-"use strict";
-
-exports.__esModule = true;
-exports.either = void 0;
-exports.oneOf = oneOf;
-
-var _annotate = require("../annotate");
-
-var _result = require("../result");
-
-var _utils = require("../_utils");
-
-var EITHER_PREFIX = 'Either:\n';
-/**
- * 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) {
-  return errText.startsWith(EITHER_PREFIX) ? errText.substr(EITHER_PREFIX.length) : itemize(errText);
-} // prettier-ignore
-
-
-function _either() {
-  for (var _len = arguments.length, decoders = new Array(_len), _key = 0; _key < _len; _key++) {
-    decoders[_key] = arguments[_key];
-  }
-
-  if (decoders.length === 0) {
-    throw new Error('Pass at least one decoder to either()');
-  }
-
-  return function (blob) {
-    // Collect errors here along the way
-    var errors = [];
-
-    for (var _i = 0; _i < decoders.length; _i++) {
-      var result = decoders[_i](blob);
-
-      if (result.ok) {
-        return result;
-      } else {
-        errors.push(result.error);
-      }
-    } // Decoding all alternatives failed, return the combined error message
-
-
-    var text = EITHER_PREFIX + errors.map(function (err) {
-      return nest((0, _utils.summarize)(err).join('\n'));
-    }).join('\n');
-    return (0, _result.err)((0, _annotate.annotate)(blob, text));
-  };
-}
-
-var either = _either;
-exports.either = either;
-
-function oneOf(constants) {
-  return function (blob) {
-    var winner = constants.find(function (c) {
-      return c === blob;
-    });
-
-    if (winner !== undefined) {
-      return (0, _result.ok)(winner);
-    }
-
-    return (0, _result.err)((0, _annotate.annotate)(blob, "Must be one of " + constants.map(function (value) {
-      return JSON.stringify(value);
-    }).join(', ')));
-  };
-}

package/core/either.mjs

@@ -1,90 +0,0 @@
-import { annotate } from '../annotate.mjs';
-import { err, ok } from '../result.mjs';
-import { indent, summarize } from '../_utils.mjs';
-var EITHER_PREFIX = 'Either:\n';
-/**
- * Indents and adds a dash in front of this (potentially multiline) string.
- */
-
-function itemize(s) {
-  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) {
-  return errText.startsWith(EITHER_PREFIX) ? errText.substr(EITHER_PREFIX.length) : itemize(errText);
-} // prettier-ignore
-
-
-function _either() {
-  for (var _len = arguments.length, decoders = new Array(_len), _key = 0; _key < _len; _key++) {
-    decoders[_key] = arguments[_key];
-  }
-
-  if (decoders.length === 0) {
-    throw new Error('Pass at least one decoder to either()');
-  }
-
-  return function (blob) {
-    // Collect errors here along the way
-    var errors = [];
-
-    for (var _i = 0; _i < decoders.length; _i++) {
-      var result = decoders[_i](blob);
-
-      if (result.ok) {
-        return result;
-      } else {
-        errors.push(result.error);
-      }
-    } // Decoding all alternatives failed, return the combined error message
-
-
-    var text = EITHER_PREFIX + errors.map(function (err) {
-      return nest(summarize(err).join('\n'));
-    }).join('\n');
-    return err(annotate(blob, text));
-  };
-}
-
-export var either = _either;
-export function oneOf(constants) {
-  return function (blob) {
-    var winner = constants.find(function (c) {
-      return c === blob;
-    });
-
-    if (winner !== undefined) {
-      return ok(winner);
-    }
-
-    return err(annotate(blob, "Must be one of " + constants.map(function (value) {
-      return JSON.stringify(value);
-    }).join(', ')));
-  };
-}

package/core/fail.d.ts

@@ -1,3 +0,0 @@
-import { Decoder } from '../_types';
-
-export function fail(msg: string): Decoder<never>;

package/core/fail.js

@@ -1,17 +0,0 @@
-"use strict";
-
-exports.__esModule = true;
-exports.fail = fail;
-
-var _annotate = require("../annotate");
-
-var _result = require("../result");
-
-/**
- * Decoder that always fails with the given error message, no matter what the input.
- */
-function fail(msg) {
-  return function (blob) {
-    return (0, _result.err)((0, _annotate.annotate)(blob, msg));
-  };
-}

package/core/fail.js.flow

@@ -1,12 +0,0 @@
-// @flow strict
-
-import { annotate } from '../annotate';
-import { err } from '../result';
-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) => err(annotate(blob, msg));
-}

package/core/fail.mjs

@@ -1,11 +0,0 @@
-import { annotate } from '../annotate.mjs';
-import { err } from '../result.mjs';
-
-/**
- * Decoder that always fails with the given error message, no matter what the input.
- */
-export function fail(msg) {
-  return function (blob) {
-    return err(annotate(blob, msg));
-  };
-}

package/core/instanceOf.d.ts

@@ -1,3 +0,0 @@
-import { Decoder } from '../_types';
-
-export function instanceOf<T>(klass: new (...args: readonly any[]) => T): Decoder<T>;

package/core/instanceOf.js

@@ -1,15 +0,0 @@
-"use strict";
-
-exports.__esModule = true;
-exports.instanceOf = instanceOf;
-
-var _annotate = require("../annotate");
-
-var _result = require("../result");
-
-function instanceOf(klass) {
-  return function (blob) {
-    return blob instanceof klass ? (0, _result.ok)(blob) : (0, _result.err)((0, _annotate.annotate)(blob, "Must be " + // $FlowFixMe[incompatible-use] - klass.name is fine?
-    klass.name + " instance"));
-  };
-}

package/core/instanceOf.js.flow

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

package/core/instanceOf.mjs

@@ -1,8 +0,0 @@
-import { annotate } from '../annotate.mjs';
-import { err, ok } from '../result.mjs';
-export function instanceOf(klass) {
-  return function (blob) {
-    return blob instanceof klass ? ok(blob) : err(annotate(blob, "Must be " + // $FlowFixMe[incompatible-use] - klass.name is fine?
-    klass.name + " instance"));
-  };
-}

package/core/json.d.ts

@@ -1,11 +0,0 @@
-import { Decoder } from '../_types';
-
-export type JSONValue = null | string | number | boolean | JSONObject | JSONArray;
-export interface JSONObject {
-    [key: string]: JSONValue;
-}
-export type JSONArray = JSONValue[];
-
-export const json: Decoder<JSONValue>;
-export const jsonArray: Decoder<JSONArray>;
-export const jsonObject: Decoder<JSONObject>;

package/core/json.js

@@ -1,31 +0,0 @@
-"use strict";
-
-exports.__esModule = true;
-exports.jsonObject = exports.jsonArray = exports.json = void 0;
-
-var _array = require("./array");
-
-var _boolean2 = require("./boolean");
-
-var _object = require("./object");
-
-var _either = require("./either");
-
-var _lazy = require("./lazy");
-
-var _constants = require("./constants");
-
-var _number = require("./number");
-
-var _string = require("./string");
-
-var jsonObject = (0, _lazy.lazy)(function () {
-  return (0, _object.dict)(json);
-});
-exports.jsonObject = jsonObject;
-var jsonArray = (0, _lazy.lazy)(function () {
-  return (0, _array.array)(json);
-});
-exports.jsonArray = jsonArray;
-var json = (0, _either.either)(_constants.null_, _string.string, _number.number, _boolean2["boolean"], jsonObject, jsonArray);
-exports.json = json;

package/core/json.js.flow

@@ -1,28 +0,0 @@
-// @flow strict
-
-import { array } from './array';
-import { boolean } from './boolean';
-import { dict } from './object';
-import { either } from './either';
-import { lazy } from './lazy';
-import { null_ } from './constants';
-import { number } from './number';
-import { string } from './string';
-import type { Decoder } from '../_types';
-
-export type JSONValue = null | string | number | boolean | JSONObject | JSONArray;
-export type JSONObject = { [string]: JSONValue };
-export type JSONArray = Array<JSONValue>;
-
-export const jsonObject: Decoder<JSONObject> = lazy(() => dict(json));
-
-export const jsonArray: Decoder<JSONArray> = lazy(() => array(json));
-
-export const json: Decoder<JSONValue> = either(
-    null_,
-    string,
-    number,
-    boolean,
-    jsonObject,
-    jsonArray,
-);

package/core/json.mjs

@@ -1,15 +0,0 @@
-import { array } from './array.mjs';
-import { boolean as _boolean } from './boolean.mjs';
-import { dict } from './object.mjs';
-import { either } from './either.mjs';
-import { lazy } from './lazy.mjs';
-import { null_ } from './constants.mjs';
-import { number } from './number.mjs';
-import { string } from './string.mjs';
-export var jsonObject = lazy(function () {
-  return dict(json);
-});
-export var jsonArray = lazy(function () {
-  return array(json);
-});
-export var json = either(null_, string, number, _boolean, jsonObject, jsonArray);

package/core/lazy.d.ts

@@ -1,3 +0,0 @@
-import { Decoder } from '../_types';
-
-export function lazy<T>(decoderFn: () => Decoder<T>): Decoder<T>;

package/core/lazy.js

@@ -1,16 +0,0 @@
-"use strict";
-
-exports.__esModule = true;
-exports.lazy = lazy;
-
-/**
- * Given an function returning a Decoder, will use that decoder to decode the
- * value. This is typically used to build decoders for recursive or
- * self-referential types.
- */
-function lazy(decoderFn) {
-  return function (blob) {
-    var decoder = decoderFn();
-    return decoder(blob);
-  };
-}

package/core/lazy.js.flow

@@ -1,15 +0,0 @@
-// @flow strict
-
-import type { Decoder } from '../_types';
-
-/**
- * Given an function returning a Decoder, will use that decoder to decode the
- * value. This is typically used to build decoders for recursive or
- * self-referential types.
- */
-export function lazy<T>(decoderFn: () => Decoder<T>): Decoder<T> {
-    return (blob: mixed) => {
-        const decoder = decoderFn();
-        return decoder(blob);
-    };
-}

package/core/lazy.mjs

@@ -1,11 +0,0 @@
-/**
- * Given an function returning a Decoder, will use that decoder to decode the
- * value. This is typically used to build decoders for recursive or
- * self-referential types.
- */
-export function lazy(decoderFn) {
-  return function (blob) {
-    var decoder = decoderFn();
-    return decoder(blob);
-  };
-}

package/core/number.d.ts

@@ -1,6 +0,0 @@
-import { Decoder } from '../_types';
-
-export const integer: Decoder<number>;
-export const number: Decoder<number>;
-export const positiveInteger: Decoder<number>;
-export const positiveNumber: Decoder<number>;

package/core/number.js

@@ -1,36 +0,0 @@
-"use strict";
-
-exports.__esModule = true;
-exports.positiveNumber = exports.positiveInteger = exports.number = exports.integer = void 0;
-
-var _annotate = require("../annotate");
-
-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'));
-};
-
-var isInteger = function isInteger(n) {
-  return Number.isInteger(n);
-};
-
-var isFinite = function isFinite(n) {
-  return Number.isFinite(n);
-};
-
-var number = (0, _composition.predicate)(anyNumber, isFinite, 'Number must be finite');
-exports.number = number;
-var positiveNumber = (0, _composition.predicate)(number, function (n) {
-  return n >= 0;
-}, 'Number must be positive'); // Integers
-
-exports.positiveNumber = positiveNumber;
-var integer = (0, _composition.predicate)(number, isInteger, 'Number must be an integer');
-exports.integer = integer;
-var positiveInteger = (0, _composition.predicate)(integer, function (n) {
-  return n >= 0;
-}, 'Number must be positive');
-exports.positiveInteger = positiveInteger;