decoders 1.26.0-beta2 → 2.0.0-beta11

package/format.mjs

@@ -0,0 +1,140 @@
+import { summarize as _summarize, asDate, INDENT, indent, isMultiline } from './_utils.mjs';
+
+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 + INDENT),
+        ser = _serializeAnnotation[0],
+        ann = _serializeAnnotation[1];
+
+    result.push(prefix + INDENT + ser + ',');
+
+    if (ann !== undefined) {
+      result.push(indent(ann, prefix + 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 + INDENT + ' '.repeat(kser.length + 2);
+
+    var _serializeAnnotation2 = serializeAnnotation(valueAnnotation, prefix + INDENT),
+        vser = _serializeAnnotation2[0],
+        vann = _serializeAnnotation2[1];
+
+    result.push(prefix + INDENT + kser + ': ' + vser + ',');
+
+    if (vann !== undefined) {
+      result.push(indent(vann, valPrefix));
+    }
+  });
+  return ['{'].concat(result, [prefix + '}']).join('\n');
+}
+
+export 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 = 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 asDate())
+      // check, then this must be the case where it's an invalid date.
+      return '(Invalid Date)';
+    } else {
+      return '(unserializable)';
+    }
+  }
+}
+export 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(isMultiline(serialized) ? 1 : serialized.length);
+    return [serialized, [sep, text].join(isMultiline(text) ? '\n' : ' ')];
+  } else {
+    return [serialized, undefined];
+  }
+}
+export function formatInline(ann) {
+  var _serializeAnnotation3 = serializeAnnotation(ann),
+      serialized = _serializeAnnotation3[0],
+      annotation = _serializeAnnotation3[1];
+
+  if (annotation !== undefined) {
+    return serialized + '\n' + annotation;
+  } else {
+    return serialized;
+  }
+}
+export function formatShort(ann) {
+  return _summarize(ann, []).join('\n');
+}

package/index.d.ts

@@ -0,0 +1,40 @@
+export { DecodeResult, Decoder, DecoderType, Scalar, define } from './Decoder';
+export { JSONValue, JSONObject, JSONArray } from './lib/json';
+
+export {
+    always,
+    constant,
+    hardcoded,
+    maybe,
+    mixed,
+    nullable,
+    null_,
+    optional,
+    undefined_,
+    unknown,
+} from './lib/basics';
+export { array, nonEmptyArray, poja, set, tuple } from './lib/arrays';
+export { boolean, numericBoolean, truthy } from './lib/booleans';
+export { date, iso8601 } from './lib/dates';
+export { dict, exact, inexact, mapping, object, pojo } from './lib/objects';
+export { either, oneOf, taggedUnion, dispatch } from './lib/unions';
+export {
+    email,
+    httpsUrl,
+    nonEmptyString,
+    regex,
+    string,
+    url,
+    uuid,
+    uuidv1,
+    uuidv4,
+} from './lib/strings';
+export { fail, instanceOf, lazy, never, prep } from './lib/utilities';
+export {
+    anyNumber,
+    integer,
+    number,
+    positiveInteger,
+    positiveNumber,
+} from './lib/numbers';
+export { json, jsonObject, jsonArray } from './lib/json';

package/index.js

@@ -0,0 +1,90 @@
+"use strict";
+
+exports.__esModule = true;
+exports.uuidv4 = exports.uuidv1 = exports.uuid = exports.url = exports.unknown = exports.undefined_ = exports.tuple = exports.truthy = exports.taggedUnion = exports.string = exports.set = exports.regex = exports.prep = 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.never = exports.mixed = exports.maybe = exports.mapping = exports.lazy = exports.jsonObject = exports.jsonArray = exports.json = exports.iso8601 = exports.integer = exports.instanceOf = exports.inexact = exports.httpsUrl = exports.hardcoded = exports.fail = exports.exact = exports.email = exports.either = exports.dispatch = exports.dict = exports.define = exports.date = exports.constant = exports["boolean"] = exports.array = exports.anyNumber = exports.always = void 0;
+
+var _Decoder = require("./Decoder");
+
+exports.define = _Decoder.define;
+
+var _basics = require("./lib/basics");
+
+exports.always = _basics.always;
+exports.constant = _basics.constant;
+exports.hardcoded = _basics.hardcoded;
+exports.maybe = _basics.maybe;
+exports.mixed = _basics.mixed;
+exports.nullable = _basics.nullable;
+exports.null_ = _basics.null_;
+exports.optional = _basics.optional;
+exports.undefined_ = _basics.undefined_;
+exports.unknown = _basics.unknown;
+
+var _arrays = require("./lib/arrays");
+
+exports.array = _arrays.array;
+exports.nonEmptyArray = _arrays.nonEmptyArray;
+exports.poja = _arrays.poja;
+exports.set = _arrays.set;
+exports.tuple = _arrays.tuple;
+
+var _booleans = require("./lib/booleans");
+
+exports["boolean"] = _booleans["boolean"];
+exports.numericBoolean = _booleans.numericBoolean;
+exports.truthy = _booleans.truthy;
+
+var _dates = require("./lib/dates");
+
+exports.date = _dates.date;
+exports.iso8601 = _dates.iso8601;
+
+var _objects = require("./lib/objects");
+
+exports.dict = _objects.dict;
+exports.exact = _objects.exact;
+exports.inexact = _objects.inexact;
+exports.mapping = _objects.mapping;
+exports.object = _objects.object;
+exports.pojo = _objects.pojo;
+
+var _unions = require("./lib/unions");
+
+exports.either = _unions.either;
+exports.oneOf = _unions.oneOf;
+exports.taggedUnion = _unions.taggedUnion;
+exports.dispatch = _unions.dispatch;
+
+var _strings = require("./lib/strings");
+
+exports.email = _strings.email;
+exports.httpsUrl = _strings.httpsUrl;
+exports.nonEmptyString = _strings.nonEmptyString;
+exports.regex = _strings.regex;
+exports.string = _strings.string;
+exports.url = _strings.url;
+exports.uuid = _strings.uuid;
+exports.uuidv1 = _strings.uuidv1;
+exports.uuidv4 = _strings.uuidv4;
+
+var _utilities = require("./lib/utilities");
+
+exports.fail = _utilities.fail;
+exports.instanceOf = _utilities.instanceOf;
+exports.lazy = _utilities.lazy;
+exports.never = _utilities.never;
+exports.prep = _utilities.prep;
+
+var _numbers = require("./lib/numbers");
+
+exports.anyNumber = _numbers.anyNumber;
+exports.integer = _numbers.integer;
+exports.number = _numbers.number;
+exports.positiveInteger = _numbers.positiveInteger;
+exports.positiveNumber = _numbers.positiveNumber;
+
+var _json = require("./lib/json");
+
+exports.json = _json.json;
+exports.jsonObject = _json.jsonObject;
+exports.jsonArray = _json.jsonArray;

package/index.js.flow

@@ -0,0 +1,44 @@
+// @flow strict
+
+export type { Decoder, DecodeResult, DecoderType, Scalar } from './Decoder';
+export type { JSONValue, JSONObject, JSONArray } from './lib/json';
+
+export { define } from './Decoder';
+
+export {
+    always,
+    constant,
+    hardcoded,
+    maybe,
+    mixed,
+    nullable,
+    null_,
+    optional,
+    undefined_,
+    unknown,
+} from './lib/basics';
+export { array, nonEmptyArray, poja, set, tuple } from './lib/arrays';
+export { boolean, numericBoolean, truthy } from './lib/booleans';
+export { date, iso8601 } from './lib/dates';
+export { dict, exact, inexact, mapping, object, pojo } from './lib/objects';
+export { either, oneOf, taggedUnion, dispatch } from './lib/unions';
+export {
+    email,
+    httpsUrl,
+    nonEmptyString,
+    regex,
+    string,
+    url,
+    uuid,
+    uuidv1,
+    uuidv4,
+} from './lib/strings';
+export { fail, instanceOf, lazy, never, prep } from './lib/utilities';
+export {
+    anyNumber,
+    integer,
+    number,
+    positiveInteger,
+    positiveNumber,
+} from './lib/numbers';
+export { json, jsonObject, jsonArray } from './lib/json';

package/index.mjs

@@ -0,0 +1,11 @@
+export { define } from './Decoder.mjs';
+export { always, constant, hardcoded, maybe, mixed, nullable, null_, optional, undefined_, unknown } from './lib/basics.mjs';
+export { array, nonEmptyArray, poja, set, tuple } from './lib/arrays.mjs';
+export { boolean, numericBoolean, truthy } from './lib/booleans.mjs';
+export { date, iso8601 } from './lib/dates.mjs';
+export { dict, exact, inexact, mapping, object, pojo } from './lib/objects.mjs';
+export { either, oneOf, taggedUnion, dispatch } from './lib/unions.mjs';
+export { email, httpsUrl, nonEmptyString, regex, string, url, uuid, uuidv1, uuidv4 } from './lib/strings.mjs';
+export { fail, instanceOf, lazy, never, prep } from './lib/utilities.mjs';
+export { anyNumber, integer, number, positiveInteger, positiveNumber } from './lib/numbers.mjs';
+export { json, jsonObject, jsonArray } from './lib/json.mjs';

package/lib/arrays.d.ts

@@ -0,0 +1,37 @@
+/// <reference lib="es6" />
+
+import { Decoder } from '../Decoder';
+
+export const poja: Decoder<unknown[]>;
+export function array<T>(decoder: Decoder<T>): Decoder<T[]>;
+export function nonEmptyArray<T>(decoder: Decoder<T>): Decoder<[T, ...T[]]>;
+export function set<T>(decoder: Decoder<T>): Decoder<Set<T>>;
+
+export function tuple<A>(a: Decoder<A>): Decoder<[A]>;
+export function tuple<A, B>(a: Decoder<A>, b: Decoder<B>): Decoder<[A, B]>;
+export function tuple<A, B, C>(
+    a: Decoder<A>,
+    b: Decoder<B>,
+    c: Decoder<C>,
+): Decoder<[A, B, C]>;
+export function tuple<A, B, C, D>(
+    a: Decoder<A>,
+    b: Decoder<B>,
+    c: Decoder<C>,
+    d: Decoder<D>,
+): Decoder<[A, B, C, D]>;
+export function tuple<A, B, C, D, E>(
+    a: Decoder<A>,
+    b: Decoder<B>,
+    c: Decoder<C>,
+    d: Decoder<D>,
+    e: Decoder<E>,
+): Decoder<[A, B, C, D, E]>;
+export function tuple<A, B, C, D, E, F>(
+    a: Decoder<A>,
+    b: Decoder<B>,
+    c: Decoder<C>,
+    d: Decoder<D>,
+    e: Decoder<E>,
+    f: Decoder<F>,
+): Decoder<[A, B, C, D, E, F]>;

package/lib/arrays.js

@@ -0,0 +1,138 @@
+"use strict";
+
+exports.__esModule = true;
+exports.array = array;
+exports.nonEmptyArray = nonEmptyArray;
+exports.poja = void 0;
+exports.set = set;
+exports.tuple = void 0;
+
+var _annotate = require("../annotate");
+
+var _Decoder = require("../Decoder");
+
+/**
+ * Accepts any array, but doesn't validate its items further.
+ *
+ * "poja" means "plain old JavaScript array", a play on `pojo()`.
+ */
+var poja = (0, _Decoder.define)(function (blob, ok, err) {
+  if (!Array.isArray(blob)) {
+    return err('Must be an array');
+  }
+
+  return ok( // NOTE: Since Flow 0.98, Array.isArray() returns $ReadOnlyArray<mixed>
+  // instead of Array<mixed>.  For rationale, see
+  // https://github.com/facebook/flow/issues/7684.  In this case, we
+  // don't want to output read-only types because it's up to the user of
+  // decoders to determine what they want to do with the decoded output.
+  // If they want to write items into the array, that's fine!
+  // The fastest way to turn a read-only array into a normal array in
+  // Javascript is to use .slice() on it, see this benchmark:
+  // http://jsben.ch/lO6C5
+  blob.slice());
+});
+/**
+ * Given an array of Result instances, loop over them all and return:
+ * - An [index, err] tuple, indicating the (index of the) first Err instance
+ *   encountered; or
+ * - a new Ok with an array of all unwrapped Ok'ed values
+ */
+
+exports.poja = poja;
+
+function all(items, blobs, // TODO: Make this less ugly
+ok, err) {
+  var results = [];
+
+  for (var index = 0; index < items.length; ++index) {
+    var result = items[index];
+
+    if (result.ok) {
+      results.push(result.value);
+    } else {
+      var ann = result.error; // Rewrite the annotation to include the index information, and inject it into the original blob
+
+      var clone = [].concat(blobs);
+      clone.splice(index, 1, (0, _annotate.annotate)(ann, ann.text ? ann.text + " (at index " + index + ")" : "index " + index));
+      return err((0, _annotate.annotate)(clone));
+    }
+  }
+
+  return ok(results);
+}
+/**
+ * Accepts arrays of whatever the given decoder accepts.
+ */
+
+
+function array(decoder) {
+  return poja.then(function (blobs, ok, err) {
+    var results = blobs.map(decoder.decode);
+    return all(results, blobs, ok, err);
+  });
+}
+/**
+ * Like `array()`, but will reject arrays with 0 elements.
+ */
+
+
+function nonEmptyArray(decoder) {
+  return array(decoder).refine(function (arr) {
+    return arr.length > 0;
+  }, 'Must be non-empty array');
+}
+/**
+ * Similar to `array()`, but returns the result as an [ES6
+ * Set](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set).
+ */
+
+
+function set(decoder) {
+  return array(decoder).transform(function (items) {
+    return new Set(items);
+  });
+}
+
+var ntuple = function ntuple(n) {
+  return poja.refine(function (arr) {
+    return arr.length === n;
+  }, "Must be a " + n + "-tuple");
+}; // prettier-ignore
+
+
+/**
+ * Accepts a tuple (an array with exactly _n_ items) of values accepted by the
+ * _n_ given decoders.
+ */
+function _tuple() {
+  for (var _len = arguments.length, decoders = new Array(_len), _key = 0; _key < _len; _key++) {
+    decoders[_key] = arguments[_key];
+  }
+
+  return ntuple(decoders.length).then(function (blobs, ok, err) {
+    var allOk = true;
+    var rvs = decoders.map(function (decoder, i) {
+      var blob = blobs[i];
+      var result = decoder.decode(blob);
+
+      if (result.ok) {
+        return result.value;
+      } else {
+        allOk = false;
+        return result.error;
+      }
+    });
+
+    if (allOk) {
+      return ok(rvs);
+    } else {
+      // If a decoder error has happened while unwrapping all the
+      // results, try to construct a good error message
+      return err((0, _annotate.annotate)(rvs));
+    }
+  });
+}
+
+var tuple = _tuple;
+exports.tuple = tuple;

package/lib/arrays.js.flow

@@ -0,0 +1,138 @@
+// @flow strict
+
+import { annotate } from '../annotate';
+import { define } from '../Decoder';
+import type { _Any } from '../_utils';
+import type { Annotation } from '../annotate';
+import type { Decoder, DecodeResult } from '../Decoder';
+
+/**
+ * Accepts any array, but doesn't validate its items further.
+ *
+ * "poja" means "plain old JavaScript array", a play on `pojo()`.
+ */
+export const poja: Decoder<Array<mixed>> = define((blob, ok, err) => {
+    if (!Array.isArray(blob)) {
+        return err('Must be an array');
+    }
+    return ok(
+        // NOTE: Since Flow 0.98, Array.isArray() returns $ReadOnlyArray<mixed>
+        // instead of Array<mixed>.  For rationale, see
+        // https://github.com/facebook/flow/issues/7684.  In this case, we
+        // don't want to output read-only types because it's up to the user of
+        // decoders to determine what they want to do with the decoded output.
+        // If they want to write items into the array, that's fine!
+        // The fastest way to turn a read-only array into a normal array in
+        // Javascript is to use .slice() on it, see this benchmark:
+        // http://jsben.ch/lO6C5
+        blob.slice(),
+    );
+});
+
+/**
+ * Given an array of Result instances, loop over them all and return:
+ * - An [index, err] tuple, indicating the (index of the) first Err instance
+ *   encountered; or
+ * - a new Ok with an array of all unwrapped Ok'ed values
+ */
+function all<T>(
+    items: $ReadOnlyArray<DecodeResult<T>>,
+    blobs: $ReadOnlyArray<mixed>,
+
+    // TODO: Make this less ugly
+    ok: (Array<T>) => DecodeResult<Array<T>>,
+    err: (Annotation) => DecodeResult<Array<T>>,
+): DecodeResult<Array<T>> {
+    const results: Array<T> = [];
+    for (let index = 0; index < items.length; ++index) {
+        const result = items[index];
+        if (result.ok) {
+            results.push(result.value);
+        } else {
+            const ann = result.error;
+
+            // Rewrite the annotation to include the index information, and inject it into the original blob
+            const clone = [...blobs];
+            clone.splice(
+                index,
+                1,
+                annotate(
+                    ann,
+                    ann.text ? `${ann.text} (at index ${index})` : `index ${index}`,
+                ),
+            );
+
+            return err(annotate(clone));
+        }
+    }
+    return ok(results);
+}
+
+/**
+ * Accepts arrays of whatever the given decoder accepts.
+ */
+export function array<T>(decoder: Decoder<T>): Decoder<Array<T>> {
+    return poja.then((blobs: $ReadOnlyArray<mixed>, ok, err) => {
+        const results = blobs.map(decoder.decode);
+        return all(results, blobs, ok, err);
+    });
+}
+
+/**
+ * Like `array()`, but will reject arrays with 0 elements.
+ */
+export function nonEmptyArray<T>(decoder: Decoder<T>): Decoder<Array<T>> {
+    return array(decoder).refine((arr) => arr.length > 0, 'Must be non-empty array');
+}
+
+/**
+ * Similar to `array()`, but returns the result as an [ES6
+ * Set](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set).
+ */
+export function set<T>(decoder: Decoder<T>): Decoder<Set<T>> {
+    return array(decoder).transform((items) => new Set(items));
+}
+
+const ntuple = (n: number) =>
+    poja.refine((arr) => arr.length === n, `Must be a ${n}-tuple`);
+
+// prettier-ignore
+interface TupleFuncSignature {
+    <A>(a: Decoder<A>): Decoder<[A]>;
+    <A, B>(a: Decoder<A>, b: Decoder<B>): Decoder<[A, B]>;
+    <A, B, C>(a: Decoder<A>, b: Decoder<B>, c: Decoder<C>): Decoder<[A, B, C]>;
+    <A, B, C, D>(a: Decoder<A>, b: Decoder<B>, c: Decoder<C>, d: Decoder<D>): Decoder<[A, B, C, D]>;
+    <A, B, C, D, E>(a: Decoder<A>, b: Decoder<B>, c: Decoder<C>, d: Decoder<D>, e: Decoder<E>): Decoder<[A, B, C, D, E]>;
+    <A, B, C, D, E, F>(a: Decoder<A>, b: Decoder<B>, c: Decoder<C>, d: Decoder<D>, e: Decoder<E>, f: Decoder<F>): Decoder<[A, B, C, D, E, F]>;
+}
+
+/**
+ * Accepts a tuple (an array with exactly _n_ items) of values accepted by the
+ * _n_ given decoders.
+ */
+function _tuple(...decoders: $ReadOnlyArray<Decoder<mixed>>): Decoder<Array<mixed>> {
+    return ntuple(decoders.length).then((blobs, ok, err) => {
+        let allOk = true;
+
+        const rvs = decoders.map((decoder, i) => {
+            const blob = blobs[i];
+            const result = decoder.decode(blob);
+            if (result.ok) {
+                return result.value;
+            } else {
+                allOk = false;
+                return result.error;
+            }
+        });
+
+        if (allOk) {
+            return ok(rvs);
+        } else {
+            // If a decoder error has happened while unwrapping all the
+            // results, try to construct a good error message
+            return err(annotate(rvs));
+        }
+    });
+}
+
+export const tuple: TupleFuncSignature = (_tuple: _Any);