decoders 2.0.0-beta1 → 2.0.0-beta5

package/{cjs/stdlib → core}/tuple.js

@@ -37,7 +37,7 @@ function tuple1(decoder1) {
     } catch (e) {
       // If a decoder error has happened while unwrapping all the
       // results, try to construct a good error message
-      return (0, _result.err)((0, _annotate.annotate)((0, _result.errValue)(result1)));
+      return (0, _result.err)((0, _annotate.annotate)([(0, _result.okOrErrValue)(result1)]));
     }
   });
 }
@@ -59,7 +59,7 @@ function tuple2(decoder1, decoder2) {
     } catch (e) {
       // If a decoder error has happened while unwrapping all the
       // results, try to construct a good error message
-      return (0, _result.err)((0, _annotate.annotate)([(0, _result.isErr)(result1) ? (0, _result.errValue)(result1) : (0, _result.value)(result1), (0, _result.isErr)(result2) ? (0, _result.errValue)(result2) : (0, _result.value)(result2)]));
+      return (0, _result.err)((0, _annotate.annotate)([(0, _result.okOrErrValue)(result1), (0, _result.okOrErrValue)(result2)]));
     }
   });
 }
@@ -83,7 +83,7 @@ function tuple3(decoder1, decoder2, decoder3) {
     } catch (e) {
       // If a decoder error has happened while unwrapping all the
       // results, try to construct a good error message
-      return (0, _result.err)((0, _annotate.annotate)([(0, _result.isErr)(result1) ? (0, _result.errValue)(result1) : (0, _result.value)(result1), (0, _result.isErr)(result2) ? (0, _result.errValue)(result2) : (0, _result.value)(result2), (0, _result.isErr)(result3) ? (0, _result.errValue)(result3) : (0, _result.value)(result3)]));
+      return (0, _result.err)((0, _annotate.annotate)([(0, _result.okOrErrValue)(result1), (0, _result.okOrErrValue)(result2), (0, _result.okOrErrValue)(result3)]));
     }
   });
 }
@@ -109,7 +109,7 @@ function tuple4(decoder1, decoder2, decoder3, decoder4) {
     } catch (e) {
       // If a decoder error has happened while unwrapping all the
       // results, try to construct a good error message
-      return (0, _result.err)((0, _annotate.annotate)([(0, _result.isErr)(result1) ? (0, _result.errValue)(result1) : (0, _result.value)(result1), (0, _result.isErr)(result2) ? (0, _result.errValue)(result2) : (0, _result.value)(result2), (0, _result.isErr)(result3) ? (0, _result.errValue)(result3) : (0, _result.value)(result3), (0, _result.isErr)(result4) ? (0, _result.errValue)(result4) : (0, _result.value)(result4)]));
+      return (0, _result.err)((0, _annotate.annotate)([(0, _result.okOrErrValue)(result1), (0, _result.okOrErrValue)(result2), (0, _result.okOrErrValue)(result3), (0, _result.okOrErrValue)(result4)]));
     }
   });
 }
@@ -137,7 +137,7 @@ function tuple5(decoder1, decoder2, decoder3, decoder4, decoder5) {
     } catch (e) {
       // If a decoder error has happened while unwrapping all the
       // results, try to construct a good error message
-      return (0, _result.err)((0, _annotate.annotate)([(0, _result.isErr)(result1) ? (0, _result.errValue)(result1) : (0, _result.value)(result1), (0, _result.isErr)(result2) ? (0, _result.errValue)(result2) : (0, _result.value)(result2), (0, _result.isErr)(result3) ? (0, _result.errValue)(result3) : (0, _result.value)(result3), (0, _result.isErr)(result4) ? (0, _result.errValue)(result4) : (0, _result.value)(result4), (0, _result.isErr)(result5) ? (0, _result.errValue)(result5) : (0, _result.value)(result5)]));
+      return (0, _result.err)((0, _annotate.annotate)([(0, _result.okOrErrValue)(result1), (0, _result.okOrErrValue)(result2), (0, _result.okOrErrValue)(result3), (0, _result.okOrErrValue)(result4), (0, _result.okOrErrValue)(result5)]));
     }
   });
 }
@@ -167,7 +167,7 @@ function tuple6(decoder1, decoder2, decoder3, decoder4, decoder5, decoder6) {
     } catch (e) {
       // If a decoder error has happened while unwrapping all the
       // results, try to construct a good error message
-      return (0, _result.err)((0, _annotate.annotate)([(0, _result.isErr)(result1) ? (0, _result.errValue)(result1) : (0, _result.value)(result1), (0, _result.isErr)(result2) ? (0, _result.errValue)(result2) : (0, _result.value)(result2), (0, _result.isErr)(result3) ? (0, _result.errValue)(result3) : (0, _result.value)(result3), (0, _result.isErr)(result4) ? (0, _result.errValue)(result4) : (0, _result.value)(result4), (0, _result.isErr)(result5) ? (0, _result.errValue)(result5) : (0, _result.value)(result5), (0, _result.isErr)(result6) ? (0, _result.errValue)(result6) : (0, _result.value)(result6)]));
+      return (0, _result.err)((0, _annotate.annotate)([(0, _result.okOrErrValue)(result1), (0, _result.okOrErrValue)(result2), (0, _result.okOrErrValue)(result3), (0, _result.okOrErrValue)(result4), (0, _result.okOrErrValue)(result5), (0, _result.okOrErrValue)(result6)]));
     }
   });
 }

package/core/tuple.js.flow

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

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

package/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/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 → index.js}

@@ -7,25 +7,25 @@ var _guard = require("./_guard");
 
 exports.guard = _guard.guard;
 
-var _composition = require("./stdlib/composition");
+var _composition = require("./core/composition");
 
 exports.compose = _composition.compose;
 exports.map = _composition.map;
 exports.predicate = _composition.predicate;
 
-var _array = require("./stdlib/array");
+var _array = require("./core/array");
 
 exports.array = _array.array;
 exports.nonEmptyArray = _array.nonEmptyArray;
 exports.poja = _array.poja;
 
-var _boolean = require("./stdlib/boolean");
+var _boolean = require("./core/boolean");
 
 exports["boolean"] = _boolean["boolean"];
 exports.numericBoolean = _boolean.numericBoolean;
 exports.truthy = _boolean.truthy;
 
-var _constants = require("./stdlib/constants");
+var _constants = require("./core/constants");
 
 exports.constant = _constants.constant;
 exports.hardcoded = _constants.hardcoded;
@@ -34,20 +34,20 @@ exports.null_ = _constants.null_;
 exports.undefined_ = _constants.undefined_;
 exports.unknown = _constants.unknown;
 
-var _date = require("./stdlib/date");
+var _date = require("./core/date");
 
 exports.date = _date.date;
 exports.iso8601 = _date.iso8601;
 
-var _describe = require("./stdlib/describe");
+var _describe = require("./core/describe");
 
 exports.describe = _describe.describe;
 
-var _dispatch = require("./stdlib/dispatch");
+var _dispatch = require("./core/dispatch");
 
 exports.dispatch = _dispatch.dispatch;
 
-var _either = require("./stdlib/either");
+var _either = require("./core/either");
 
 exports.either = _either.either;
 exports.either3 = _either.either3;
@@ -59,50 +59,50 @@ exports.either8 = _either.either8;
 exports.either9 = _either.either9;
 exports.oneOf = _either.oneOf;
 
-var _fail = require("./stdlib/fail");
+var _fail = require("./core/fail");
 
 exports.fail = _fail.fail;
 
-var _instanceOf = require("./stdlib/instanceOf");
+var _instanceOf = require("./core/instanceOf");
 
 exports.instanceOf = _instanceOf.instanceOf;
 
-var _json = require("./stdlib/json");
+var _json = require("./core/json");
 
 exports.json = _json.json;
 exports.jsonObject = _json.jsonObject;
 exports.jsonArray = _json.jsonArray;
 
-var _lazy = require("./stdlib/lazy");
+var _lazy = require("./core/lazy");
 
 exports.lazy = _lazy.lazy;
 
-var _mapping = require("./stdlib/mapping");
+var _mapping = require("./core/mapping");
 
 exports.mapping = _mapping.mapping;
 exports.dict = _mapping.dict;
 
-var _number = require("./stdlib/number");
+var _number = require("./core/number");
 
 exports.integer = _number.integer;
 exports.number = _number.number;
 exports.positiveInteger = _number.positiveInteger;
 exports.positiveNumber = _number.positiveNumber;
 
-var _object = require("./stdlib/object");
+var _object = require("./core/object");
 
 exports.exact = _object.exact;
 exports.inexact = _object.inexact;
 exports.object = _object.object;
 exports.pojo = _object.pojo;
 
-var _optional = require("./stdlib/optional");
+var _optional = require("./core/optional");
 
 exports.maybe = _optional.maybe;
 exports.nullable = _optional.nullable;
 exports.optional = _optional.optional;
 
-var _string = require("./stdlib/string");
+var _string = require("./core/string");
 
 exports.email = _string.email;
 exports.nonEmptyString = _string.nonEmptyString;
@@ -110,7 +110,7 @@ exports.regex = _string.regex;
 exports.string = _string.string;
 exports.url = _string.url;
 
-var _tuple = require("./stdlib/tuple");
+var _tuple = require("./core/tuple");
 
 exports.tuple1 = _tuple.tuple1;
 exports.tuple2 = _tuple.tuple2;

package/index.js.flow

@@ -0,0 +1,63 @@
+// @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/package.json

@@ -1,6 +1,6 @@
 {
     "name": "decoders",
-    "version": "2.0.0-beta1",
+    "version": "2.0.0-beta5",
     "description": "Elegant and battle-tested validation library for type-safe input data (for TypeScript and Flow)",
     "license": "MIT",
     "repository": {
@@ -12,16 +12,8 @@
     "bugs": {
         "url": "https://github.com/nvie/decoders/issues"
     },
-    "main": "./cjs/index.js",
-    "module": "./es/index.js",
-    "type": "module",
-    "exports": {
-        "require": "./cjs/index.js",
-        "import": "./es/index.js"
-    },
-    "engines": {
-        "node": ">=12"
-    },
+    "main": "./index.js",
+    "module": "./_esm/index.js",
     "keywords": [
         "decoder",
         "decoders",
@@ -48,7 +40,6 @@
         "map",
         "predicate"
     ],
-    "types": "./ts/index.d.ts",
     "githubUrl": "https://github.com/nvie/decoders",
     "sideEffects": false
 }