decoders 2.0.0-beta3 → 2.0.0-beta7

package/_esm/result.js.flow

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