decoders 2.0.0-beta8 → 2.0.1

package/core/either.js.flow

@@ -1,151 +0,0 @@
-// @flow strict
-
-import { annotate } from '../annotate';
-import { err, ok, orElse } from '../result';
-import { indent, summarize } from '../_utils';
-import type { Decoder, Scalar } from '../_types';
-
-/**
- * Indents and adds a dash in front of this (potentially multiline) 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) =>
-        orElse(d1(blob), (err1) =>
-            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 err(annotate(blob, text));
-            }),
-        );
-}
-
-export function either3<T1, T2, T3>(
-    d1: Decoder<T1>,
-    d2: Decoder<T2>,
-    d3: Decoder<T3>,
-): Decoder<T1 | T2 | T3> {
-    return either(d1, either(d2, d3));
-}
-
-export function either4<T1, T2, T3, T4>(
-    d1: Decoder<T1>,
-    d2: Decoder<T2>,
-    d3: Decoder<T3>,
-    d4: Decoder<T4>,
-): Decoder<T1 | T2 | T3 | T4> {
-    return either(d1, either3(d2, d3, d4));
-}
-
-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> {
-    return either(d1, either4(d2, d3, d4, d5));
-}
-
-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> {
-    return either(d1, either5(d2, d3, d4, d5, d6));
-}
-
-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> {
-    return either(d1, either6(d2, d3, d4, d5, d6, d7));
-}
-
-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> {
-    return either(d1, either7(d2, d3, d4, d5, d6, d7, d8));
-}
-
-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> {
-    return either(d1, either8(d2, d3, d4, d5, d6, d7, d8, d9));
-}
-
-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 err(
-            annotate(
-                blob,
-                `Must be one of ${constants
-                    .map((value) => JSON.stringify(value))
-                    .join(', ')}`,
-            ),
-        );
-    };
-}

package/core/either.mjs

@@ -1,90 +0,0 @@
-import { annotate } from '../annotate.mjs';
-import { err, ok, orElse } from '../result.mjs';
-import { indent, summarize } from '../_utils.mjs';
-
-/**
- * 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) {
-  var EITHER_PREFIX = 'Either:\n';
-  return errText.startsWith(EITHER_PREFIX) ? errText.substr(EITHER_PREFIX.length) : itemize(errText);
-}
-
-export function either(d1, d2) {
-  return function (blob) {
-    return orElse(d1(blob), function (err1) {
-      return orElse(d2(blob), function (err2) {
-        var serr1 = summarize(err1).join('\n');
-        var serr2 = summarize(err2).join('\n');
-        var text = ['Either:', nest(serr1), nest(serr2)].join('\n');
-        return err(annotate(blob, text));
-      });
-    });
-  };
-}
-export function either3(d1, d2, d3) {
-  return either(d1, either(d2, d3));
-}
-export function either4(d1, d2, d3, d4) {
-  return either(d1, either3(d2, d3, d4));
-}
-export function either5(d1, d2, d3, d4, d5) {
-  return either(d1, either4(d2, d3, d4, d5));
-}
-export function either6(d1, d2, d3, d4, d5, d6) {
-  return either(d1, either5(d2, d3, d4, d5, d6));
-}
-export function either7(d1, d2, d3, d4, d5, d6, d7) {
-  return either(d1, either6(d2, d3, d4, d5, d6, d7));
-}
-export function either8(d1, d2, d3, d4, d5, d6, d7, d8) {
-  return either(d1, either7(d2, d3, d4, d5, d6, d7, d8));
-}
-export function either9(d1, d2, d3, d4, d5, d6, d7, d8, d9) {
-  return either(d1, either8(d2, d3, d4, d5, d6, d7, d8, d9));
-}
-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: 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 _mapping = require("./mapping");
-
-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, _mapping.dict)(json);
-});
-exports.jsonObject = jsonObject;
-var jsonArray = (0, _lazy.lazy)(function () {
-  return (0, _array.array)(json);
-});
-exports.jsonArray = jsonArray;
-var json = (0, _either.either6)(_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 './mapping';
-import { either6 } 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> = either6(
-    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 './mapping.mjs';
-import { either6 } 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 = either6(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/mapping.d.ts

@@ -1,6 +0,0 @@
-/// <reference lib="es6" />
-
-import { Decoder } from '../_types';
-
-export function mapping<T>(decoder: Decoder<T>): Decoder<Map<string, T>>;
-export function dict<T>(decoder: Decoder<T>): Decoder<{ [key: string]: T }>;

package/core/mapping.js

@@ -1,67 +0,0 @@
-"use strict";
-
-exports.__esModule = true;
-exports.dict = dict;
-exports.mapping = mapping;
-
-var _annotate = require("../annotate");
-
-var _composition = require("./composition");
-
-var _result = require("../result");
-
-var _object = require("./object");
-
-/**
- * Like mapping(), but returns an object rather than a Map instance.
- */
-function dict(decoder) {
-  return (0, _composition.compose)(_object.pojo, function (blob) {
-    var rv = {};
-    var errors = null;
-    Object.keys(blob).forEach(function (key) {
-      var value = blob[key];
-      var result = decoder(value);
-
-      if (result.type === 'ok') {
-        if (errors === null) {
-          rv[key] = result.value;
-        }
-      } else {
-        rv = {}; // Clear the success value so it can get garbage collected early
-
-        if (errors === null) {
-          errors = {};
-        }
-
-        errors[key] = result.error;
-      }
-    });
-
-    if (errors !== null) {
-      return (0, _result.err)((0, _annotate.merge)((0, _annotate.annotateObject)(blob), errors));
-    } else {
-      return (0, _result.ok)(rv);
-    }
-  });
-}
-/**
- * Given an object, will decode a Map of string keys to whatever values.
- *
- * For example, given a decoder for a Person, we can verify a Person lookup
- * table structure (of type Map<string, Person>) like so:
- *
- *   mapping(person)
- *
- */
-
-
-function mapping(decoder) {
-  return (0, _composition.map)(dict(decoder), function (obj) {
-    return new Map( // This is effectively Object.entries(obj), but in a way that Flow
-    // will know the types are okay
-    Object.keys(obj).map(function (key) {
-      return [key, obj[key]];
-    }));
-  });
-}

package/core/mapping.js.flow

@@ -1,62 +0,0 @@
-// @flow strict
-
-import { annotateObject } from '../annotate';
-import { compose, map } from './composition';
-import { err, ok } from '../result';
-import { merge } from '../annotate';
-import { pojo } from './object';
-import type { Annotation } from '../annotate';
-import type { Decoder } from '../_types';
-
-/**
- * Like mapping(), but returns an object rather than a Map instance.
- */
-export function dict<T>(decoder: Decoder<T>): Decoder<{ [string]: T }> {
-    return compose(pojo, (blob: { +[key: string]: mixed }) => {
-        let rv: { [key: string]: T } = {};
-        let errors: { [key: string]: Annotation } | null = null;
-
-        Object.keys(blob).forEach((key: string) => {
-            const value = blob[key];
-            const result = decoder(value);
-            if (result.type === 'ok') {
-                if (errors === null) {
-                    rv[key] = result.value;
-                }
-            } else {
-                rv = {}; // Clear the success value so it can get garbage collected early
-                if (errors === null) {
-                    errors = {};
-                }
-                errors[key] = result.error;
-            }
-        });
-
-        if (errors !== null) {
-            return err(merge(annotateObject(blob), errors));
-        } else {
-            return ok(rv);
-        }
-    });
-}
-
-/**
- * Given an object, will decode a Map of string keys to whatever values.
- *
- * For example, given a decoder for a Person, we can verify a Person lookup
- * table structure (of type Map<string, Person>) like so:
- *
- *   mapping(person)
- *
- */
-export function mapping<T>(decoder: Decoder<T>): Decoder<Map<string, T>> {
-    return map(
-        dict(decoder),
-        (obj) =>
-            new Map(
-                // This is effectively Object.entries(obj), but in a way that Flow
-                // will know the types are okay
-                Object.keys(obj).map((key) => [key, obj[key]]),
-            ),
-    );
-}

package/core/mapping.mjs

@@ -1,58 +0,0 @@
-import { annotateObject } from '../annotate.mjs';
-import { compose, map } from './composition.mjs';
-import { err, ok } from '../result.mjs';
-import { merge } from '../annotate.mjs';
-import { pojo } from './object.mjs';
-
-/**
- * Like mapping(), but returns an object rather than a Map instance.
- */
-export function dict(decoder) {
-  return compose(pojo, function (blob) {
-    var rv = {};
-    var errors = null;
-    Object.keys(blob).forEach(function (key) {
-      var value = blob[key];
-      var result = decoder(value);
-
-      if (result.type === 'ok') {
-        if (errors === null) {
-          rv[key] = result.value;
-        }
-      } else {
-        rv = {}; // Clear the success value so it can get garbage collected early
-
-        if (errors === null) {
-          errors = {};
-        }
-
-        errors[key] = result.error;
-      }
-    });
-
-    if (errors !== null) {
-      return err(merge(annotateObject(blob), errors));
-    } else {
-      return ok(rv);
-    }
-  });
-}
-/**
- * Given an object, will decode a Map of string keys to whatever values.
- *
- * For example, given a decoder for a Person, we can verify a Person lookup
- * table structure (of type Map<string, Person>) like so:
- *
- *   mapping(person)
- *
- */
-
-export function mapping(decoder) {
-  return map(dict(decoder), function (obj) {
-    return new Map( // This is effectively Object.entries(obj), but in a way that Flow
-    // will know the types are okay
-    Object.keys(obj).map(function (key) {
-      return [key, obj[key]];
-    }));
-  });
-}

package/core/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>;