decoders 1.26.0-beta2 → 2.0.0-beta3

package/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("./core/composition");
+
+exports.compose = _composition.compose;
+exports.map = _composition.map;
+exports.predicate = _composition.predicate;
+
+var _array = require("./core/array");
+
+exports.array = _array.array;
+exports.nonEmptyArray = _array.nonEmptyArray;
+exports.poja = _array.poja;
+
+var _boolean = require("./core/boolean");
+
+exports["boolean"] = _boolean["boolean"];
+exports.numericBoolean = _boolean.numericBoolean;
+exports.truthy = _boolean.truthy;
+
+var _constants = require("./core/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("./core/date");
+
+exports.date = _date.date;
+exports.iso8601 = _date.iso8601;
+
+var _describe = require("./core/describe");
+
+exports.describe = _describe.describe;
+
+var _dispatch = require("./core/dispatch");
+
+exports.dispatch = _dispatch.dispatch;
+
+var _either = require("./core/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("./core/fail");
+
+exports.fail = _fail.fail;
+
+var _instanceOf = require("./core/instanceOf");
+
+exports.instanceOf = _instanceOf.instanceOf;
+
+var _json = require("./core/json");
+
+exports.json = _json.json;
+exports.jsonObject = _json.jsonObject;
+exports.jsonArray = _json.jsonArray;
+
+var _lazy = require("./core/lazy");
+
+exports.lazy = _lazy.lazy;
+
+var _mapping = require("./core/mapping");
+
+exports.mapping = _mapping.mapping;
+exports.dict = _mapping.dict;
+
+var _number = require("./core/number");
+
+exports.integer = _number.integer;
+exports.number = _number.number;
+exports.positiveInteger = _number.positiveInteger;
+exports.positiveNumber = _number.positiveNumber;
+
+var _object = require("./core/object");
+
+exports.exact = _object.exact;
+exports.inexact = _object.inexact;
+exports.object = _object.object;
+exports.pojo = _object.pojo;
+
+var _optional = require("./core/optional");
+
+exports.maybe = _optional.maybe;
+exports.nullable = _optional.nullable;
+exports.optional = _optional.optional;
+
+var _string = require("./core/string");
+
+exports.email = _string.email;
+exports.nonEmptyString = _string.nonEmptyString;
+exports.regex = _string.regex;
+exports.string = _string.string;
+exports.url = _string.url;
+
+var _tuple = require("./core/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

@@ -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 { 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": "1.26.0-beta2",
+    "version": "2.0.0-beta3",
     "description": "Elegant and battle-tested validation library for type-safe input data (for TypeScript and Flow)",
     "license": "MIT",
     "repository": {
@@ -12,8 +12,8 @@
     "bugs": {
         "url": "https://github.com/nvie/decoders/issues"
     },
-    "main": "./cjs/index.js",
-    "module": "./es/index.js",
+    "main": "./index.js",
+    "module": "./_esm/index.js",
     "keywords": [
         "decoder",
         "decoders",
@@ -40,14 +40,6 @@
         "map",
         "predicate"
     ],
-    "peerDependencies": {
-        "@babel/runtime": "^7.16.0"
-    },
-    "dependencies": {
-        "debrief": "^1.6.0-beta2",
-        "lemons": "^1.7.0-beta2"
-    },
-    "types": "./ts/index.d.ts",
     "githubUrl": "https://github.com/nvie/decoders",
     "sideEffects": false
 }

package/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));
+}

package/result.js.flow

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

@@ -1,133 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.array = array;
-exports.nonEmptyArray = nonEmptyArray;
-exports.poja = void 0;
-
-var _debrief = require("debrief");
-
-var _lemons = require("lemons");
-
-var _utils = require("./utils");
-
-function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
-
-function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
-
-function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
-
-function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
-
-function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
-
-function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
-
-function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
-
-/**
- * Like a "Plain Old JavaScript Object", but for arrays: "Plain Old JavaScript
- * Array" ^_^
- */
-var poja = function poja(blob) {
-  if (!Array.isArray(blob)) {
-    return (0, _lemons.Err)((0, _debrief.annotate)(blob, 'Must be an array'));
-  }
-
-  return (0, _lemons.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 iterable of Result instances, exhaust 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(iterable, blobs) {
-  var results = [];
-  var index = 0;
-
-  var _iterator = _createForOfIteratorHelper(iterable),
-      _step;
-
-  try {
-    for (_iterator.s(); !(_step = _iterator.n()).done;) {
-      var result = _step.value;
-
-      try {
-        var value = result.unwrap();
-        results.push(value);
-      } catch (ann) {
-        // Rewrite the annotation to include the index information, and inject it into the original blob
-        var clone = _toConsumableArray(blobs);
-
-        clone.splice(index, 1, (0, _debrief.annotate)(ann, ann.annotation !== undefined ? "".concat(ann.annotation, " (at index ").concat(index, ")") : "index ".concat(index))); // const errValue = [];
-        // if (index > 0) {
-        //     errValue.push('...'); // TODO: make special mark, not string!
-        // }
-        // errValue.push(
-        // );
-        // if (index < iterable.length - 1) {
-        //     errValue.push('...'); // TODO: make special mark, not string!
-        // }
-
-        return (0, _lemons.Err)((0, _debrief.annotate)(clone));
-      }
-
-      index++;
-    }
-  } catch (err) {
-    _iterator.e(err);
-  } finally {
-    _iterator.f();
-  }
-
-  return (0, _lemons.Ok)(results);
-}
-/**
- * Given a T, builds a decoder that assumes an array input and returns an
- * Array<T>.
- */
-
-
-function members(decoder) {
-  return function (blobs) {
-    var results = blobs.map(decoder);
-    var result = all(results, blobs);
-    return result;
-  };
-}
-/**
- * Builds a Decoder that returns Ok for values of `Array<T>`, given a Decoder
- * for `T`.  Err otherwise.
- */
-
-
-function array(decoder) {
-  return (0, _utils.compose)(poja, members(decoder));
-}
-/**
- * Builds a Decoder that returns Ok for values of `Array<T>`, but will reject
- * empty arrays.
- */
-
-
-function nonEmptyArray(decoder) {
-  return (0, _utils.compose)(array(decoder), (0, _utils.predicate)(function (arr) {
-    return arr.length > 0;
-  }, 'Must be non-empty array'));
-}