decoders 2.0.0-beta5 → 2.0.0-beta9

package/_esm/core/tuple.js.flow

@@ -1,215 +0,0 @@
-// @flow strict
-
-import { annotate } from '../annotate';
-import { compose, predicate } from './composition';
-import { err, ok, okOrErrValue, unwrap } from '../result';
-import { poja } from './array';
-import type { Decoder } from '../_types';
-
-const ntuple = (n: number) =>
-    compose(
-        poja,
-        predicate((arr) => arr.length === n, `Must be a ${n}-tuple`),
-    );
-
-/**
- * Builds a Decoder that returns Ok for 1-tuple of [T], given a Decoder for T.
- * Err otherwise.
- */
-export function tuple1<T>(decoder1: Decoder<T>): Decoder<[T]> {
-    return compose(ntuple(1), (blobs: $ReadOnlyArray<mixed>) => {
-        const [blob1] = blobs;
-
-        const result1 = decoder1(blob1);
-        try {
-            return ok([unwrap(result1)]);
-        } catch (e) {
-            // If a decoder error has happened while unwrapping all the
-            // results, try to construct a good error message
-            return err(annotate([okOrErrValue(result1)]));
-        }
-    });
-}
-
-/**
- * Builds a Decoder that returns Ok for 2-tuples of [T1, T2], given Decoders
- * for T1 and T2.  Err otherwise.
- */
-export function tuple2<T1, T2>(
-    decoder1: Decoder<T1>,
-    decoder2: Decoder<T2>,
-): Decoder<[T1, T2]> {
-    return compose(ntuple(2), (blobs: $ReadOnlyArray<mixed>) => {
-        const [blob1, blob2] = blobs;
-
-        const result1 = decoder1(blob1);
-        const result2 = decoder2(blob2);
-        try {
-            return ok([unwrap(result1), unwrap(result2)]);
-        } catch (e) {
-            // If a decoder error has happened while unwrapping all the
-            // results, try to construct a good error message
-            return err(annotate([okOrErrValue(result1), okOrErrValue(result2)]));
-        }
-    });
-}
-
-/**
- * Builds a Decoder that returns Ok for 3-tuples of [T1, T2, T3], given
- * Decoders for T1, T2, and T3.  Err otherwise.
- */
-export function tuple3<T1, T2, T3>(
-    decoder1: Decoder<T1>,
-    decoder2: Decoder<T2>,
-    decoder3: Decoder<T3>,
-): Decoder<[T1, T2, T3]> {
-    return compose(ntuple(3), (blobs: $ReadOnlyArray<mixed>) => {
-        const [blob1, blob2, blob3] = blobs;
-
-        const result1 = decoder1(blob1);
-        const result2 = decoder2(blob2);
-        const result3 = decoder3(blob3);
-        try {
-            return ok([unwrap(result1), unwrap(result2), unwrap(result3)]);
-        } catch (e) {
-            // If a decoder error has happened while unwrapping all the
-            // results, try to construct a good error message
-            return err(
-                annotate([
-                    okOrErrValue(result1),
-                    okOrErrValue(result2),
-                    okOrErrValue(result3),
-                ]),
-            );
-        }
-    });
-}
-
-/**
- * Builds a Decoder that returns Ok for 4-tuples of [T1, T2, T3, T4], given
- * Decoders for T1, T2, T3, and T4.  Err otherwise.
- */
-export function tuple4<T1, T2, T3, T4>(
-    decoder1: Decoder<T1>,
-    decoder2: Decoder<T2>,
-    decoder3: Decoder<T3>,
-    decoder4: Decoder<T4>,
-): Decoder<[T1, T2, T3, T4]> {
-    return compose(ntuple(4), (blobs: $ReadOnlyArray<mixed>) => {
-        const [blob1, blob2, blob3, blob4] = blobs;
-
-        const result1 = decoder1(blob1);
-        const result2 = decoder2(blob2);
-        const result3 = decoder3(blob3);
-        const result4 = decoder4(blob4);
-        try {
-            return ok([
-                unwrap(result1),
-                unwrap(result2),
-                unwrap(result3),
-                unwrap(result4),
-            ]);
-        } catch (e) {
-            // If a decoder error has happened while unwrapping all the
-            // results, try to construct a good error message
-            return err(
-                annotate([
-                    okOrErrValue(result1),
-                    okOrErrValue(result2),
-                    okOrErrValue(result3),
-                    okOrErrValue(result4),
-                ]),
-            );
-        }
-    });
-}
-
-/**
- * Builds a Decoder that returns Ok for 5-tuples of [T1, T2, T3, T4, T5], given
- * Decoders for T1, T2, T3, T4, and T5.  Err otherwise.
- */
-export function tuple5<T1, T2, T3, T4, T5>(
-    decoder1: Decoder<T1>,
-    decoder2: Decoder<T2>,
-    decoder3: Decoder<T3>,
-    decoder4: Decoder<T4>,
-    decoder5: Decoder<T5>,
-): Decoder<[T1, T2, T3, T4, T5]> {
-    return compose(ntuple(5), (blobs: $ReadOnlyArray<mixed>) => {
-        const [blob1, blob2, blob3, blob4, blob5] = blobs;
-
-        const result1 = decoder1(blob1);
-        const result2 = decoder2(blob2);
-        const result3 = decoder3(blob3);
-        const result4 = decoder4(blob4);
-        const result5 = decoder5(blob5);
-        try {
-            return ok([
-                unwrap(result1),
-                unwrap(result2),
-                unwrap(result3),
-                unwrap(result4),
-                unwrap(result5),
-            ]);
-        } catch (e) {
-            // If a decoder error has happened while unwrapping all the
-            // results, try to construct a good error message
-            return err(
-                annotate([
-                    okOrErrValue(result1),
-                    okOrErrValue(result2),
-                    okOrErrValue(result3),
-                    okOrErrValue(result4),
-                    okOrErrValue(result5),
-                ]),
-            );
-        }
-    });
-}
-
-/**
- * Builds a Decoder that returns Ok for 5-tuples of [T1, T2, T3, T4, T5], given
- * Decoders for T1, T2, T3, T4, T5, and T6.  Err otherwise.
- */
-export function tuple6<T1, T2, T3, T4, T5, T6>(
-    decoder1: Decoder<T1>,
-    decoder2: Decoder<T2>,
-    decoder3: Decoder<T3>,
-    decoder4: Decoder<T4>,
-    decoder5: Decoder<T5>,
-    decoder6: Decoder<T6>,
-): Decoder<[T1, T2, T3, T4, T5, T6]> {
-    return compose(ntuple(6), (blobs: $ReadOnlyArray<mixed>) => {
-        const [blob1, blob2, blob3, blob4, blob5, blob6] = blobs;
-
-        const result1 = decoder1(blob1);
-        const result2 = decoder2(blob2);
-        const result3 = decoder3(blob3);
-        const result4 = decoder4(blob4);
-        const result5 = decoder5(blob5);
-        const result6 = decoder6(blob6);
-        try {
-            return ok([
-                unwrap(result1),
-                unwrap(result2),
-                unwrap(result3),
-                unwrap(result4),
-                unwrap(result5),
-                unwrap(result6),
-            ]);
-        } catch (e) {
-            // If a decoder error has happened while unwrapping all the
-            // results, try to construct a good error message
-            return err(
-                annotate([
-                    okOrErrValue(result1),
-                    okOrErrValue(result2),
-                    okOrErrValue(result3),
-                    okOrErrValue(result4),
-                    okOrErrValue(result5),
-                    okOrErrValue(result6),
-                ]),
-            );
-        }
-    });
-}

package/_esm/format/index.js

@@ -1,2 +0,0 @@
-export { formatInline } from './inline';
-export { formatShort } from './short';

package/_esm/format/index.js.flow

@@ -1,4 +0,0 @@
-// @flow strict
-
-export { formatInline } from './inline';
-export { formatShort } from './short';

package/_esm/format/short.js

@@ -1,4 +0,0 @@
-import { summarize as _summarize } from '../_utils';
-export function formatShort(ann) {
-  return _summarize(ann, []).join('\n');
-}

package/_esm/format/short.js.flow

@@ -1,8 +0,0 @@
-// @flow strict
-
-import { summarize as _summarize } from '../_utils';
-import type { Annotation } from '../annotate';
-
-export function formatShort(ann: Annotation): string {
-    return _summarize(ann, []).join('\n');
-}

package/_esm/index.js.flow

@@ -1,63 +0,0 @@
-// @flow strict
-
-/**
- * Elm-like JSON decoders, for use with Flow.
- * See http://elmplayground.com/decoding-json-in-elm-1 for an introduction.
- *
- * Why? All JSON responses coming from our API endpoints are just that: free-form
- * JSON data.  To Flow, the only type classification possilbe is "any" -- effectively
- * turning off all type checks for anything related to JSON.  To the receiving end
- * (our frontend), the structure of that data is completely opaque to any type
- * checkers since JSON values can be anything: an object, an array, null, a string,
- * a bool, etc.  Our type system is not a runtime type system, so we need a way of
- * "converting" an any-type JSON value into a type that we want to work with in our
- * frontend code base.
- *
- * Elm's solution to this problem is to define composable decoders: functions that
- * take anything and either fail with an error, or guarantee to return the expected
- * type.  In our case, it's fine to fail with a runtime error.
- *
- */
-export type {
-    Decoder,
-    DecodeResult,
-    DecoderType,
-    Guard,
-    GuardType,
-    Predicate,
-    Scalar,
-} from './_types';
-export type { Result } from './result';
-export type { JSONValue, JSONObject, JSONArray } from './core/json';
-
-export { guard } from './_guard';
-
-export { compose, map, predicate } from './core/composition';
-
-export { array, nonEmptyArray, poja } from './core/array';
-export { boolean, numericBoolean, truthy } from './core/boolean';
-export { constant, hardcoded, mixed, null_, undefined_, unknown } from './core/constants';
-export { date, iso8601 } from './core/date';
-export { describe } from './core/describe';
-export { dispatch } from './core/dispatch';
-export {
-    either,
-    either3,
-    either4,
-    either5,
-    either6,
-    either7,
-    either8,
-    either9,
-    oneOf,
-} from './core/either';
-export { fail } from './core/fail';
-export { instanceOf } from './core/instanceOf';
-export { json, jsonObject, jsonArray } from './core/json';
-export { lazy } from './core/lazy';
-export { mapping, dict } from './core/mapping';
-export { integer, number, positiveInteger, positiveNumber } from './core/number';
-export { exact, inexact, object, pojo } from './core/object';
-export { maybe, nullable, optional } from './core/optional';
-export { email, nonEmptyString, regex, string, url } from './core/string';
-export { tuple1, tuple2, tuple3, tuple4, tuple5, tuple6 } from './core/tuple';

package/_esm/result.js

@@ -1,148 +0,0 @@
-/**
- * Result <value> <error>
- *     = Ok <value>
- *     | Err <error>
- */
-
-/**
- * Create a new Result instance representing a successful computation.
- */
-export function ok(value) {
-  return {
-    type: 'ok',
-    value: value,
-    error: undefined
-  };
-}
-/**
- * Create a new Result instance representing a failed computation.
- */
-
-export function err(error) {
-  return {
-    type: 'err',
-    value: undefined,
-    error: error
-  };
-}
-export function toString(result) {
-  return result.type === 'ok' ? "Ok(" + String(result.value) + ")" : "Err(" + String(result.error) + ")";
-}
-export function isOk(result) {
-  return result.type === 'ok';
-}
-export function isErr(result) {
-  return result.type === 'err';
-}
-export function withDefault(result, defaultValue) {
-  return result.type === 'ok' ? result.value : defaultValue;
-} // TODO: Remove this from the public API? The same can be achieved now with
-// TODO: const { value } = result;
-
-export function okValue(result) {
-  return result.type === 'ok' ? result.value : undefined;
-} // TODO: Remove this from the public API? The same can be achieved now with
-// TODO: const { error } = result;
-
-export function errValue(result) {
-  return result.type === 'err' ? result.error : undefined;
-}
-export function okOrErrValue(result) {
-  return result.type === 'ok' ? result.value : result.error;
-}
-/**
- * Unwrap the value from this Result instance if this is an "Ok" result.
- * Otherwise, will throw the "Err" error via a runtime exception.
- */
-
-export function unwrap(result) {
-  if (result.type === 'ok') {
-    return result.value;
-  } else {
-    throw result.error;
-  }
-}
-export function expect(result, message) {
-  if (result.type === 'ok') {
-    return result.value;
-  } else {
-    throw message instanceof Error ? message : new Error(message);
-  }
-}
-export function dispatch(result, okCallback, errCallback) {
-  return result.type === 'ok' ? okCallback(result.value) : errCallback(result.error);
-}
-/**
- * If the given result is OK, defers to the other result. Otherwise returns the
- * error result.
- *
- * It's like saying A && B, but on Result.
- *
- * Examples:
- *
- *     Result.ok(42)     && Result.ok('hi')    // => Ok('hi')
- *     Result.err('boo') && Result.ok('hi')    // => Err('boo')
- *     Result.ok(42)     && Result.err('boo')  // => Err('boo')
- *     Result.err('boo') && Result.err('boo')  // => Err('boo')
- *
- */
-// export function and<T, E, T2>(
-//     result1: Result<T, E>,
-//     result2: Result<T2, E>,
-// ): Result<T2, E> {
-//     return result1.type === 'ok' ? result2 : result1;
-// }
-
-/**
- * If the given result is OK, return that result. Otherwise, defers to the
- * other result.
- *
- * It's like saying A || B, but on Result.
- *
- * Examples:
- *
- *     Result.ok(42)      || Result.ok('hi')    // => Ok(42)
- *     Result.err('boo')  || Result.ok('hi')    // => Ok('hi')
- *     Result.ok(42)      || Result.err('boo')  // => Ok(42)
- *     Result.err('bleh') || Result.err('boo')  // => Err('boo')
- *
- */
-// export function or<T, E, E2>(
-//     result1: Result<T, E>,
-//     result2: Result<T, E2>,
-// ): Result<T, E2> {
-//     return result1.type === 'ok' ? result1 : result2;
-// }
-
-/**
- * Like .and(), aka &&, but the second argument gets evaluated lazily only if
- * the first result is an Ok result. If so, it has access to the Ok value from
- * the first argument.
- */
-
-export function andThen(result1, lazyResult2) {
-  return result1.type === 'ok' ? lazyResult2(result1.value) : result1;
-}
-/**
- * Like .or(), aka ||, but the second argument gets evaluated lazily only if
- * the first result is an Err result. If so, it has access to the Err value
- * from the first argument.
- */
-
-export function orElse(result1, lazyResult2) {
-  return result1.type === 'ok' ? result1 : lazyResult2(result1.error);
-}
-/**
- * Transform an Ok result. Will not touch Err results.
- */
-
-export function mapOk(result, mapper) {
-  return result.type === 'ok' ? ok(mapper(result.value)) : result;
-}
-/**
- * Transform an Err value. Will not touch Ok results.
- */
-
-export function mapError(result, mapper) {
-  return result.type === 'ok' ? result : err(mapper(result.error));
-}

package/_esm/result.js.flow

@@ -1,174 +0,0 @@
-// @flow strict
-
-/**
- * Result <value> <error>
- *     = Ok <value>
- *     | Err <error>
- */
-
-type Ok<+T> = {| +type: 'ok', +value: T, +error: void |};
-type Err<+E> = {| +type: 'err', +value: void, +error: E |};
-
-export type Result<+T, +E> = Ok<T> | Err<E>;
-
-/**
- * Create a new Result instance representing a successful computation.
- */
-export function ok<T>(value: T): Ok<T> {
-    return { type: 'ok', value, error: undefined };
-}
-
-/**
- * Create a new Result instance representing a failed computation.
- */
-export function err<E>(error: E): Err<E> {
-    return { type: 'err', value: undefined, error };
-}
-
-export function toString(result: Result<mixed, mixed>): string {
-    return result.type === 'ok'
-        ? `Ok(${String(result.value)})`
-        : `Err(${String(result.error)})`;
-}
-
-export function isOk(result: Result<mixed, mixed>): boolean {
-    return result.type === 'ok';
-}
-
-export function isErr(result: Result<mixed, mixed>): boolean {
-    return result.type === 'err';
-}
-
-export function withDefault<T>(result: Result<T, mixed>, defaultValue: T): T {
-    return result.type === 'ok' ? result.value : defaultValue;
-}
-
-// TODO: Remove this from the public API? The same can be achieved now with
-// TODO: const { value } = result;
-export function okValue<T>(result: Result<T, mixed>): void | T {
-    return result.type === 'ok' ? result.value : undefined;
-}
-
-// TODO: Remove this from the public API? The same can be achieved now with
-// TODO: const { error } = result;
-export function errValue<E>(result: Result<mixed, E>): void | E {
-    return result.type === 'err' ? result.error : undefined;
-}
-
-export function okOrErrValue<T, E>(result: Result<T, E>): T | E {
-    return result.type === 'ok' ? result.value : result.error;
-}
-
-/**
- * Unwrap the value from this Result instance if this is an "Ok" result.
- * Otherwise, will throw the "Err" error via a runtime exception.
- */
-export function unwrap<T>(result: Result<T, mixed>): T {
-    if (result.type === 'ok') {
-        return result.value;
-    } else {
-        throw result.error;
-    }
-}
-
-export function expect<T>(result: Result<T, mixed>, message: string | Error): T {
-    if (result.type === 'ok') {
-        return result.value;
-    } else {
-        throw message instanceof Error ? message : new Error(message);
-    }
-}
-
-export function dispatch<T, E, O>(
-    result: Result<T, E>,
-    okCallback: (value: T) => O,
-    errCallback: (error: E) => O,
-): O {
-    return result.type === 'ok' ? okCallback(result.value) : errCallback(result.error);
-}
-
-/**
- * If the given result is OK, defers to the other result. Otherwise returns the
- * error result.
- *
- * It's like saying A && B, but on Result.
- *
- * Examples:
- *
- *     Result.ok(42)     && Result.ok('hi')    // => Ok('hi')
- *     Result.err('boo') && Result.ok('hi')    // => Err('boo')
- *     Result.ok(42)     && Result.err('boo')  // => Err('boo')
- *     Result.err('boo') && Result.err('boo')  // => Err('boo')
- *
- */
-// export function and<T, E, T2>(
-//     result1: Result<T, E>,
-//     result2: Result<T2, E>,
-// ): Result<T2, E> {
-//     return result1.type === 'ok' ? result2 : result1;
-// }
-
-/**
- * If the given result is OK, return that result. Otherwise, defers to the
- * other result.
- *
- * It's like saying A || B, but on Result.
- *
- * Examples:
- *
- *     Result.ok(42)      || Result.ok('hi')    // => Ok(42)
- *     Result.err('boo')  || Result.ok('hi')    // => Ok('hi')
- *     Result.ok(42)      || Result.err('boo')  // => Ok(42)
- *     Result.err('bleh') || Result.err('boo')  // => Err('boo')
- *
- */
-// export function or<T, E, E2>(
-//     result1: Result<T, E>,
-//     result2: Result<T, E2>,
-// ): Result<T, E2> {
-//     return result1.type === 'ok' ? result1 : result2;
-// }
-
-/**
- * Like .and(), aka &&, but the second argument gets evaluated lazily only if
- * the first result is an Ok result. If so, it has access to the Ok value from
- * the first argument.
- */
-export function andThen<T, E, T2>(
-    result1: Result<T, E>,
-    lazyResult2: (value: T) => Result<T2, E>,
-): Result<T2, E> {
-    return result1.type === 'ok' ? lazyResult2(result1.value) : result1;
-}
-
-/**
- * Like .or(), aka ||, but the second argument gets evaluated lazily only if
- * the first result is an Err result. If so, it has access to the Err value
- * from the first argument.
- */
-export function orElse<T, E, E2>(
-    result1: Result<T, E>,
-    lazyResult2: (errValue: E) => Result<T, E2>,
-): Result<T, E2> {
-    return result1.type === 'ok' ? result1 : lazyResult2(result1.error);
-}
-
-/**
- * Transform an Ok result. Will not touch Err results.
- */
-export function mapOk<T, E, T2>(
-    result: Result<T, E>,
-    mapper: (value: T) => T2,
-): Result<T2, E> {
-    return result.type === 'ok' ? ok(mapper(result.value)) : result;
-}
-
-/**
- * Transform an Err value. Will not touch Ok results.
- */
-export function mapError<T, E, E2>(
-    result: Result<T, E>,
-    mapper: (error: E) => E2,
-): Result<T, E2> {
-    return result.type === 'ok' ? result : err(mapper(result.error));
-}

package/core/mapping.js

@@ -1,67 +0,0 @@
-"use strict";
-
-exports.__esModule = true;
-exports.dict = dict;
-exports.mapping = mapping;
-
-var Result = _interopRequireWildcard(require("../result"));
-
-var _annotate = require("../annotate");
-
-var _composition = require("./composition");
-
-var _object = require("./object");
-
-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 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.compose)(_object.pojo, function (blob) {
-    var tuples = [];
-    var errors = null;
-    Object.keys(blob).forEach(function (key) {
-      var value = blob[key];
-      var result = decoder(value);
-
-      if (result.type === 'ok') {
-        if (errors === null) {
-          tuples.push([key, result.value]);
-        }
-      } else {
-        tuples.length = 0; // Clear the tuples array
-
-        if (errors === null) {
-          errors = {};
-        }
-
-        errors[key] = result.error;
-      }
-    });
-
-    if (errors !== null) {
-      return Result.err((0, _annotate.merge)((0, _annotate.annotateObject)(blob), errors));
-    } else {
-      return Result.ok(new Map(tuples));
-    }
-  });
-}
-/**
- * Like mapping(), but returns an object rather than a Map instance.
- */
-
-
-function dict(decoder) {
-  return (0, _composition.map)(mapping(decoder), function (m) {
-    return Object.fromEntries(m);
-  });
-}