decoders 2.0.0-beta6 → 2.0.0-beta7

package/_esm/core/tuple.js.flow

@@ -1,214 +0,0 @@
-// @flow strict
-
-import { annotate } from '../annotate';
-import { compose, predicate } from './composition';
-import { err, ok, unwrap } from '../result';
-import { poja } from './array';
-import type { Decoder } from '../_types';
-import type { Result } from '../result';
-
-function okOrErr<T, E>(result: Result<T, E>): T | E {
-    return result.type === 'ok' ? result.value : result.error;
-}
-
-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([okOrErr(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([okOrErr(result1), okOrErr(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([okOrErr(result1), okOrErr(result2), okOrErr(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([
-                    okOrErr(result1),
-                    okOrErr(result2),
-                    okOrErr(result3),
-                    okOrErr(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([
-                    okOrErr(result1),
-                    okOrErr(result2),
-                    okOrErr(result3),
-                    okOrErr(result4),
-                    okOrErr(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([
-                    okOrErr(result1),
-                    okOrErr(result2),
-                    okOrErr(result3),
-                    okOrErr(result4),
-                    okOrErr(result5),
-                    okOrErr(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/result.js.flow

@@ -1,158 +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;
-}
-
-/**
- * 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');
-}