decoders 1.25.4 → 2.0.0-beta1

package/cjs/format/index.js

@@ -0,0 +1,12 @@
+"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/cjs/format/index.js.flow

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

package/cjs/format/inline.js

@@ -0,0 +1,146 @@
+"use strict";
+
+exports.__esModule = true;
+exports.formatInline = formatInline;
+exports.serializeAnnotation = serializeAnnotation;
+exports.serializeValue = serializeValue;
+
+var _utils = require("../_utils");
+
+function serializeString(s, width) {
+  if (width === void 0) {
+    width = 80;
+  }
+
+  // Full string
+  // Abbreviated to $maxlen i.e. "Vincent Driess..." [truncated]
+  var ser = JSON.stringify(s);
+
+  if (ser.length <= width) {
+    return ser;
+  } // Cut off a bit
+
+
+  var truncated = s.substring(0, width - 15) + '...';
+  ser = JSON.stringify(truncated) + ' [truncated]';
+  return ser;
+}
+
+function serializeArray(annotation, prefix) {
+  var items = annotation.items;
+
+  if (items.length === 0) {
+    return '[]';
+  }
+
+  var result = [];
+  items.forEach(function (item) {
+    var _serializeAnnotation = serializeAnnotation(item, prefix + _utils.INDENT),
+        ser = _serializeAnnotation[0],
+        ann = _serializeAnnotation[1];
+
+    result.push(prefix + _utils.INDENT + ser + ',');
+
+    if (ann !== undefined) {
+      result.push((0, _utils.indent)(ann, prefix + _utils.INDENT));
+    }
+  });
+  return ['['].concat(result, [prefix + ']']).join('\n');
+}
+
+function serializeObject(annotation, prefix) {
+  var fields = annotation.fields;
+  var fieldNames = Object.keys(fields);
+
+  if (fieldNames.length === 0) {
+    return '{}';
+  }
+
+  var result = [];
+  fieldNames.forEach(function (key) {
+    var valueAnnotation = fields[key];
+    var kser = serializeValue(key);
+    var valPrefix = prefix + _utils.INDENT + ' '.repeat(kser.length + 2);
+
+    var _serializeAnnotation2 = serializeAnnotation(valueAnnotation, prefix + _utils.INDENT),
+        vser = _serializeAnnotation2[0],
+        vann = _serializeAnnotation2[1];
+
+    result.push(prefix + _utils.INDENT + kser + ': ' + vser + ',');
+
+    if (vann !== undefined) {
+      result.push((0, _utils.indent)(vann, valPrefix));
+    }
+  });
+  return ['{'].concat(result, [prefix + '}']).join('\n');
+}
+
+function serializeValue(value) {
+  // 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 {
+    var valueAsDate = (0, _utils.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)';
+    }
+  }
+}
+
+function serializeAnnotation(ann, prefix) {
+  if (prefix === void 0) {
+    prefix = '';
+  }
+
+  // The serialized data (the input object echoed back)
+  var 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);
+  }
+
+  var text = ann.text;
+
+  if (text !== undefined) {
+    var sep = '^'.repeat((0, _utils.isMultiline)(serialized) ? 1 : serialized.length);
+    return [serialized, [sep, text].join((0, _utils.isMultiline)(text) ? '\n' : ' ')];
+  } else {
+    return [serialized, undefined];
+  }
+}
+
+function formatInline(ann) {
+  var _serializeAnnotation3 = serializeAnnotation(ann),
+      serialized = _serializeAnnotation3[0],
+      annotation = _serializeAnnotation3[1];
+
+  if (annotation !== undefined) {
+    return serialized + '\n' + annotation;
+  } else {
+    return serialized;
+  }
+}

package/cjs/format/inline.js.flow

@@ -0,0 +1,122 @@
+// @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/cjs/format/short.js

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

package/cjs/format/short.js.flow

@@ -0,0 +1,8 @@
+// @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/cjs/index.js

@@ -0,0 +1,120 @@
+"use strict";
+
+exports.__esModule = true;
+exports.url = exports.unknown = exports.undefined_ = exports.tuple6 = exports.tuple5 = exports.tuple4 = exports.tuple3 = exports.tuple2 = exports.tuple1 = exports.truthy = exports.string = exports.regex = exports.predicate = exports.positiveNumber = exports.positiveInteger = exports.pojo = exports.poja = exports.optional = exports.oneOf = exports.object = exports.numericBoolean = exports.number = exports.nullable = exports.null_ = exports.nonEmptyString = exports.nonEmptyArray = exports.mixed = exports.maybe = exports.mapping = exports.map = exports.lazy = exports.jsonObject = exports.jsonArray = exports.json = exports.iso8601 = exports.integer = exports.instanceOf = exports.inexact = exports.hardcoded = exports.guard = exports.fail = exports.exact = exports.email = exports.either9 = exports.either8 = exports.either7 = exports.either6 = exports.either5 = exports.either4 = exports.either3 = exports.either = exports.dispatch = exports.dict = exports.describe = exports.date = exports.constant = exports.compose = exports["boolean"] = exports.array = void 0;
+
+var _guard = require("./_guard");
+
+exports.guard = _guard.guard;
+
+var _composition = require("./stdlib/composition");
+
+exports.compose = _composition.compose;
+exports.map = _composition.map;
+exports.predicate = _composition.predicate;
+
+var _array = require("./stdlib/array");
+
+exports.array = _array.array;
+exports.nonEmptyArray = _array.nonEmptyArray;
+exports.poja = _array.poja;
+
+var _boolean = require("./stdlib/boolean");
+
+exports["boolean"] = _boolean["boolean"];
+exports.numericBoolean = _boolean.numericBoolean;
+exports.truthy = _boolean.truthy;
+
+var _constants = require("./stdlib/constants");
+
+exports.constant = _constants.constant;
+exports.hardcoded = _constants.hardcoded;
+exports.mixed = _constants.mixed;
+exports.null_ = _constants.null_;
+exports.undefined_ = _constants.undefined_;
+exports.unknown = _constants.unknown;
+
+var _date = require("./stdlib/date");
+
+exports.date = _date.date;
+exports.iso8601 = _date.iso8601;
+
+var _describe = require("./stdlib/describe");
+
+exports.describe = _describe.describe;
+
+var _dispatch = require("./stdlib/dispatch");
+
+exports.dispatch = _dispatch.dispatch;
+
+var _either = require("./stdlib/either");
+
+exports.either = _either.either;
+exports.either3 = _either.either3;
+exports.either4 = _either.either4;
+exports.either5 = _either.either5;
+exports.either6 = _either.either6;
+exports.either7 = _either.either7;
+exports.either8 = _either.either8;
+exports.either9 = _either.either9;
+exports.oneOf = _either.oneOf;
+
+var _fail = require("./stdlib/fail");
+
+exports.fail = _fail.fail;
+
+var _instanceOf = require("./stdlib/instanceOf");
+
+exports.instanceOf = _instanceOf.instanceOf;
+
+var _json = require("./stdlib/json");
+
+exports.json = _json.json;
+exports.jsonObject = _json.jsonObject;
+exports.jsonArray = _json.jsonArray;
+
+var _lazy = require("./stdlib/lazy");
+
+exports.lazy = _lazy.lazy;
+
+var _mapping = require("./stdlib/mapping");
+
+exports.mapping = _mapping.mapping;
+exports.dict = _mapping.dict;
+
+var _number = require("./stdlib/number");
+
+exports.integer = _number.integer;
+exports.number = _number.number;
+exports.positiveInteger = _number.positiveInteger;
+exports.positiveNumber = _number.positiveNumber;
+
+var _object = require("./stdlib/object");
+
+exports.exact = _object.exact;
+exports.inexact = _object.inexact;
+exports.object = _object.object;
+exports.pojo = _object.pojo;
+
+var _optional = require("./stdlib/optional");
+
+exports.maybe = _optional.maybe;
+exports.nullable = _optional.nullable;
+exports.optional = _optional.optional;
+
+var _string = require("./stdlib/string");
+
+exports.email = _string.email;
+exports.nonEmptyString = _string.nonEmptyString;
+exports.regex = _string.regex;
+exports.string = _string.string;
+exports.url = _string.url;
+
+var _tuple = require("./stdlib/tuple");
+
+exports.tuple1 = _tuple.tuple1;
+exports.tuple2 = _tuple.tuple2;
+exports.tuple3 = _tuple.tuple3;
+exports.tuple4 = _tuple.tuple4;
+exports.tuple5 = _tuple.tuple5;
+exports.tuple6 = _tuple.tuple6;

package/{index.js.flow → cjs/index.js.flow}

@@ -18,17 +18,28 @@
  * type.  In our case, it's fine to fail with a runtime error.
  *
  */
-import type { $DecoderType, $GuardType, Decoder, Guard } from './types';
+export type { Decoder, Guard } from './_types';
+export type { DecoderType, GuardType } from './_types';
 
-export { guard } from './guard';
-export { compose, map, predicate } from './utils';
+export type { JSONValue, JSONObject, JSONArray } from './stdlib/json';
 
-export { array, nonEmptyArray, poja } from './array';
-export { boolean, numericBoolean, truthy } from './boolean';
-export { constant, hardcoded, mixed, null_, undefined_, unknown } from './constants';
-export { date, iso8601 } from './date';
-export { describe } from './describe';
-export { dispatch } from './dispatch';
+export { guard } from './_guard';
+
+export { compose, map, predicate } from './stdlib/composition';
+
+export { array, nonEmptyArray, poja } from './stdlib/array';
+export { boolean, numericBoolean, truthy } from './stdlib/boolean';
+export {
+    constant,
+    hardcoded,
+    mixed,
+    null_,
+    undefined_,
+    unknown,
+} from './stdlib/constants';
+export { date, iso8601 } from './stdlib/date';
+export { describe } from './stdlib/describe';
+export { dispatch } from './stdlib/dispatch';
 export {
     either,
     either3,
@@ -39,18 +50,14 @@ export {
     either8,
     either9,
     oneOf,
-} from './either';
-export { fail } from './fail';
-export { instanceOf } from './instanceOf';
-export { json, jsonObject, jsonArray } from './json';
-export { lazy } from './lazy';
-export { mapping, dict } from './mapping';
-export { integer, number, positiveInteger, positiveNumber } from './number';
-export { exact, inexact, object, pojo } from './object';
-export { maybe, nullable, optional } from './optional';
-export { email, nonEmptyString, regex, string, url } from './string';
-export { tuple1, tuple2, tuple3, tuple4, tuple5, tuple6 } from './tuple';
-
-export type { Decoder, Guard };
-export type { $DecoderType, $GuardType };
-export type { JSONValue, JSONObject, JSONArray } from './json';
+} from './stdlib/either';
+export { fail } from './stdlib/fail';
+export { instanceOf } from './stdlib/instanceOf';
+export { json, jsonObject, jsonArray } from './stdlib/json';
+export { lazy } from './stdlib/lazy';
+export { mapping, dict } from './stdlib/mapping';
+export { integer, number, positiveInteger, positiveNumber } from './stdlib/number';
+export { exact, inexact, object, pojo } from './stdlib/object';
+export { maybe, nullable, optional } from './stdlib/optional';
+export { email, nonEmptyString, regex, string, url } from './stdlib/string';
+export { tuple1, tuple2, tuple3, tuple4, tuple5, tuple6 } from './stdlib/tuple';

package/cjs/result.js

@@ -0,0 +1,172 @@
+"use strict";
+
+exports.__esModule = true;
+exports.andThen = andThen;
+exports.dispatch = dispatch;
+exports.err = err;
+exports.errValue = errValue;
+exports.expect = expect;
+exports.isErr = isErr;
+exports.isOk = isOk;
+exports.map = map;
+exports.mapError = mapError;
+exports.ok = ok;
+exports.orElse = orElse;
+exports.toString = toString;
+exports.unwrap = unwrap;
+exports.value = value;
+exports.withDefault = withDefault;
+
+/**
+ * Result <value> <error>
+ *     = Ok <value>
+ *     | Err <error>
+ */
+
+/**
+ * Create a new Result instance representing a successful computation.
+ */
+function ok(value) {
+  return {
+    type: 'ok',
+    value: value
+  };
+}
+/**
+ * Create a new Result instance representing a failed computation.
+ */
+
+
+function err(error) {
+  return {
+    type: 'err',
+    error: error
+  };
+}
+
+function toString(result) {
+  return result.type === 'ok' ? "Ok(" + String(result.value) + ")" : "Err(" + String(result.error) + ")";
+}
+
+function isOk(result) {
+  return result.type === 'ok';
+}
+
+function isErr(result) {
+  return result.type === 'err';
+}
+
+function withDefault(result, defaultValue) {
+  return result.type === 'ok' ? result.value : defaultValue;
+}
+
+function value(result) {
+  return result.type === 'ok' ? result.value : undefined;
+}
+
+function errValue(result) {
+  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.
+ */
+
+
+function unwrap(result) {
+  if (result.type === 'ok') {
+    return result.value;
+  } else {
+    throw result.error;
+  }
+}
+
+function expect(result, message) {
+  if (result.type === 'ok') {
+    return result.value;
+  } else {
+    throw message instanceof Error ? message : new Error(message);
+  }
+}
+
+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.
+ */
+
+
+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.
+ */
+
+
+function orElse(result1, lazyResult2) {
+  return result1.type === 'ok' ? result1 : lazyResult2(result1.error);
+}
+/**
+ * Transform an Ok result. Will not touch Err results.
+ */
+
+
+function map(result, mapper) {
+  return result.type === 'ok' ? ok(mapper(result.value)) : result;
+}
+/**
+ * Transform an Err value. Will not touch Ok results.
+ */
+
+
+function mapError(result, mapper) {
+  return result.type === 'ok' ? result : err(mapper(result.error));
+}