decoders 2.0.0-beta4 → 2.0.0-beta8

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.flow

@@ -1,170 +0,0 @@
-// @flow strict
-
-/**
- * Result <value> <error>
- *     = Ok <value>
- *     | Err <error>
- */
-
-type Ok<+T> = {| +type: 'ok', +value: T |};
-type Err<+E> = {| +type: 'err', +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 };
-}
-
-/**
- * Create a new Result instance representing a failed computation.
- */
-export function err<E>(error: E): Err<E> {
-    return { type: 'err', 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;
-}
-
-export function okValue<T>(result: Result<T, mixed>): void | T {
-    return result.type === 'ok' ? result.value : undefined;
-}
-
-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/format/index.js

@@ -1,12 +0,0 @@
-"use strict";
-
-exports.__esModule = true;
-exports.formatShort = exports.formatInline = void 0;
-
-var _inline = require("./inline");
-
-exports.formatInline = _inline.formatInline;
-
-var _short = require("./short");
-
-exports.formatShort = _short.formatShort;

package/format/index.js.flow

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

package/format/inline.js.flow

@@ -1,122 +0,0 @@
-// @flow strict
-
-import { asDate, indent, INDENT, isMultiline } from '../_utils';
-import type { Annotation, ArrayAnnotation, ObjectAnnotation } from '../annotate';
-
-function serializeString(s: string, width: number = 80): string {
-    // Full string
-    // Abbreviated to $maxlen i.e. "Vincent Driess..." [truncated]
-    let ser = JSON.stringify(s);
-    if (ser.length <= width) {
-        return ser;
-    }
-
-    // Cut off a bit
-    const truncated = s.substring(0, width - 15) + '...';
-    ser = JSON.stringify(truncated) + ' [truncated]';
-    return ser;
-}
-
-function serializeArray(annotation: ArrayAnnotation, prefix: string): string {
-    const { items } = annotation;
-    if (items.length === 0) {
-        return '[]';
-    }
-
-    const result = [];
-    items.forEach((item) => {
-        const [ser, ann] = serializeAnnotation(item, prefix + INDENT);
-        result.push(prefix + INDENT + ser + ',');
-        if (ann !== undefined) {
-            result.push(indent(ann, prefix + INDENT));
-        }
-    });
-    return ['[', ...result, prefix + ']'].join('\n');
-}
-
-function serializeObject(annotation: ObjectAnnotation, prefix: string): string {
-    const { fields } = annotation;
-
-    const fieldNames = Object.keys(fields);
-    if (fieldNames.length === 0) {
-        return '{}';
-    }
-
-    const result = [];
-    fieldNames.forEach((key) => {
-        const valueAnnotation = fields[key];
-        const kser = serializeValue(key);
-
-        const valPrefix = prefix + INDENT + ' '.repeat(kser.length + 2);
-        const [vser, vann] = serializeAnnotation(valueAnnotation, prefix + INDENT);
-
-        result.push(prefix + INDENT + kser + ': ' + vser + ',');
-        if (vann !== undefined) {
-            result.push(indent(vann, valPrefix));
-        }
-    });
-    return ['{', ...result, prefix + '}'].join('\n');
-}
-
-export function serializeValue(value: mixed): string {
-    // istanbul ignore else
-    if (typeof value === 'string') {
-        return serializeString(value);
-    } else if (typeof value === 'number' || typeof value === 'boolean') {
-        return value.toString();
-    } else if (value === null) {
-        return 'null';
-    } else if (value === undefined) {
-        return 'undefined';
-    } else {
-        const valueAsDate = asDate(value);
-        if (valueAsDate !== null) {
-            return `new Date(${JSON.stringify(valueAsDate.toISOString())})`;
-        } else if (value instanceof Date) {
-            // NOTE: Using `instanceof Date` is unreliable way of checking dates.
-            // If this case occurs (and it didn't pass the prior isDate())
-            // check, then this must be the case where it's an invalid date.
-            return '(Invalid Date)';
-        } else {
-            return '(unserializable)';
-        }
-    }
-}
-
-export function serializeAnnotation(
-    ann: Annotation,
-    prefix: string = '',
-): [string, string | void] {
-    // The serialized data (the input object echoed back)
-    let serialized;
-    if (ann.type === 'array') {
-        serialized = serializeArray(ann, prefix);
-    } else if (ann.type === 'object') {
-        serialized = serializeObject(ann, prefix);
-    } else if (ann.type === 'function') {
-        serialized = '<function>';
-    } else if (ann.type === 'circular-ref') {
-        serialized = '<circular ref>';
-    } else if (ann.type === 'unknown') {
-        serialized = '???';
-    } else {
-        serialized = serializeValue(ann.value);
-    }
-
-    const text = ann.text;
-    if (text !== undefined) {
-        const sep = '^'.repeat(isMultiline(serialized) ? 1 : serialized.length);
-        return [serialized, [sep, text].join(isMultiline(text) ? '\n' : ' ')];
-    } else {
-        return [serialized, undefined];
-    }
-}
-
-export function formatInline(ann: Annotation): string {
-    const [serialized, annotation] = serializeAnnotation(ann);
-    if (annotation !== undefined) {
-        return serialized + '\n' + annotation;
-    } else {
-        return serialized;
-    }
-}

package/format/short.js

@@ -1,10 +0,0 @@
-"use strict";
-
-exports.__esModule = true;
-exports.formatShort = formatShort;
-
-var _utils = require("../_utils");
-
-function formatShort(ann) {
-  return (0, _utils.summarize)(ann, []).join('\n');
-}

package/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');
-}