decoders 1.25.5 → 2.0.0-beta2

package/either.d.ts

@@ -1,61 +0,0 @@
-import { Decoder, Scalar } from './types';
-
-export function either<T1, T2>(d1: Decoder<T1>, d2: Decoder<T2>): Decoder<T1 | T2>;
-export function either2<T1, T2>(d1: Decoder<T1>, d2: Decoder<T2>): Decoder<T1 | T2>;
-export function either3<T1, T2, T3>(
-    d1: Decoder<T1>,
-    d2: Decoder<T2>,
-    d3: Decoder<T3>
-): Decoder<T1 | T2 | T3>;
-export function either4<T1, T2, T3, T4>(
-    d1: Decoder<T1>,
-    d2: Decoder<T2>,
-    d3: Decoder<T3>,
-    d4: Decoder<T4>
-): Decoder<T1 | T2 | T3 | T4>;
-export function either5<T1, T2, T3, T4, T5>(
-    d1: Decoder<T1>,
-    d2: Decoder<T2>,
-    d3: Decoder<T3>,
-    d4: Decoder<T4>,
-    d5: Decoder<T5>
-): Decoder<T1 | T2 | T3 | T4 | T5>;
-export function either6<T1, T2, T3, T4, T5, T6>(
-    d1: Decoder<T1>,
-    d2: Decoder<T2>,
-    d3: Decoder<T3>,
-    d4: Decoder<T4>,
-    d5: Decoder<T5>,
-    d6: Decoder<T6>
-): Decoder<T1 | T2 | T3 | T4 | T5 | T6>;
-export function either7<T1, T2, T3, T4, T5, T6, T7>(
-    d1: Decoder<T1>,
-    d2: Decoder<T2>,
-    d3: Decoder<T3>,
-    d4: Decoder<T4>,
-    d5: Decoder<T5>,
-    d6: Decoder<T6>,
-    d7: Decoder<T7>
-): Decoder<T1 | T2 | T3 | T4 | T5 | T6 | T7>;
-export function either8<T1, T2, T3, T4, T5, T6, T7, T8>(
-    d1: Decoder<T1>,
-    d2: Decoder<T2>,
-    d3: Decoder<T3>,
-    d4: Decoder<T4>,
-    d5: Decoder<T5>,
-    d6: Decoder<T6>,
-    d7: Decoder<T7>,
-    d8: Decoder<T8>
-): Decoder<T1 | T2 | T3 | T4 | T5 | T6 | T7 | T8>;
-export function either9<T1, T2, T3, T4, T5, T6, T7, T8, T9>(
-    d1: Decoder<T1>,
-    d2: Decoder<T2>,
-    d3: Decoder<T3>,
-    d4: Decoder<T4>,
-    d5: Decoder<T5>,
-    d6: Decoder<T6>,
-    d7: Decoder<T7>,
-    d8: Decoder<T8>,
-    d9: Decoder<T9>
-): Decoder<T1 | T2 | T3 | T4 | T5 | T6 | T7 | T8 | T9>;
-export function oneOf<T extends Scalar>(constants: readonly T[]): Decoder<T>;

package/either.js

@@ -1,85 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.either = either;
-exports.either3 = either3;
-exports.either4 = either4;
-exports.either5 = either5;
-exports.either6 = either6;
-exports.either7 = either7;
-exports.either8 = either8;
-exports.either9 = either9;
-exports.oneOf = oneOf;
-
-var _debrief = require("debrief");
-
-var _Result = require("lemons/Result");
-
-/**
- * Indents and adds a dash in front of this (potentially multiline) string.
- */
-// istanbul ignore next
-function itemize() {
-  var s = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
-  return '-' + (0, _debrief.indent)(s).substring(1);
-}
-
-function either(d1, d2) {
-  return function (blob) {
-    return d1(blob).dispatch(function (value1) {
-      return (0, _Result.Ok)(value1);
-    }, function (err1) {
-      return d2(blob).dispatch(function (value2) {
-        return (0, _Result.Ok)(value2);
-      }, function (err2) {
-        return (0, _Result.Err)((0, _debrief.annotate)(blob, ['Either:', itemize((0, _debrief.summarize)(err1).join('\n')), itemize((0, _debrief.summarize)(err2).join('\n'))].join('\n')));
-      });
-    });
-  };
-}
-
-function either3(d1, d2, d3) {
-  return either(d1, either(d2, d3));
-}
-
-function either4(d1, d2, d3, d4) {
-  return either(d1, either3(d2, d3, d4));
-}
-
-function either5(d1, d2, d3, d4, d5) {
-  return either(d1, either4(d2, d3, d4, d5));
-}
-
-function either6(d1, d2, d3, d4, d5, d6) {
-  return either(d1, either5(d2, d3, d4, d5, d6));
-}
-
-function either7(d1, d2, d3, d4, d5, d6, d7) {
-  return either(d1, either6(d2, d3, d4, d5, d6, d7));
-}
-
-function either8(d1, d2, d3, d4, d5, d6, d7, d8) {
-  return either(d1, either7(d2, d3, d4, d5, d6, d7, d8));
-}
-
-function either9(d1, d2, d3, d4, d5, d6, d7, d8, d9) {
-  return either(d1, either8(d2, d3, d4, d5, d6, d7, d8, d9));
-}
-
-function oneOf(constants) {
-  return function (blob) {
-    var winner = constants.find(function (c) {
-      return c === blob;
-    });
-
-    if (winner !== undefined) {
-      return (0, _Result.Ok)(winner);
-    }
-
-    return (0, _Result.Err)((0, _debrief.annotate)(blob, "Must be one of ".concat(constants.map(function (value) {
-      return JSON.stringify(value);
-    }).join(', '))));
-  };
-}

package/fail.d.ts

@@ -1,3 +0,0 @@
-import { Decoder } from './types';
-
-export function fail(msg: string): Decoder<never>;

package/fail.js

@@ -1,19 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.fail = fail;
-
-var _debrief = require("debrief");
-
-var _Result = require("lemons/Result");
-
-/**
- * Decoder that always fails with the given error message, no matter what the input.
- */
-function fail(msg) {
-  return function (blob) {
-    return (0, _Result.Err)((0, _debrief.annotate)(blob, msg));
-  };
-}

package/fail.js.flow

@@ -1,13 +0,0 @@
-// @flow strict
-
-import { annotate } from 'debrief';
-import { Err } from 'lemons/Result';
-
-import type { Decoder } from './types';
-
-/**
- * Decoder that always fails with the given error message, no matter what the input.
- */
-export function fail(msg: string): Decoder<empty> {
-    return (blob: mixed) => Err(annotate(blob, msg));
-}

package/guard.d.ts

@@ -1,7 +0,0 @@
-import { Decoder, Guard } from './types';
-
-export interface Options {
-    style?: 'inline' | 'simple';
-}
-
-export function guard<T>(decoder: Decoder<T>, options?: Options): Guard<T>;

package/guard.js

@@ -1,30 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.guard = guard;
-
-var _debrief = require("debrief");
-
-/**
- * Alternative for serialize() that does not echo back the input value.
- */
-function serializeSimple(annotation) {
-  return (0, _debrief.summarize)(annotation).join('\n');
-}
-
-function guard(decoder, options) {
-  var o = options || {};
-  var style = o.style || 'inline';
-  var serializer = style === 'inline' ? _debrief.serialize // Normal serializer, which echoes back inputted value and inlines errors
-  : serializeSimple; // Only returns error messages, without echoing back input
-
-  return function (blob) {
-    return decoder(blob).mapError(function (annotation) {
-      var err = new Error('\n' + serializer(annotation));
-      err.name = 'Decoding error';
-      return err;
-    }).unwrap();
-  };
-}

package/guard.js.flow

@@ -1,36 +0,0 @@
-// @flow strict
-
-import { serialize as serializeInline, summarize } from 'debrief';
-import type { Annotation } from 'debrief';
-
-import type { Decoder, Guard } from './types';
-
-type Options = {|
-    style?: 'inline' | 'simple', // `inline` by default
-|};
-
-/**
- * Alternative for serialize() that does not echo back the input value.
- */
-function serializeSimple(annotation: Annotation) {
-    return summarize(annotation).join('\n');
-}
-
-export function guard<T>(decoder: Decoder<T>, options?: Options): Guard<T> {
-    const o = options || {};
-    const style = o.style || 'inline';
-
-    const serializer =
-        style === 'inline'
-            ? serializeInline // Normal serializer, which echoes back inputted value and inlines errors
-            : serializeSimple; // Only returns error messages, without echoing back input
-
-    return (blob: mixed) =>
-        decoder(blob)
-            .mapError((annotation) => {
-                const err = new Error('\n' + serializer(annotation));
-                err.name = 'Decoding error';
-                return err;
-            })
-            .unwrap();
-}

package/helpers.d.ts

@@ -1,79 +0,0 @@
-/**
- * Given a type like:
- *
- *   {
- *     a: string;
- *     b: number | undefined;
- *     c: null | undefined;
- *     d: null;
- *     e: undefined;
- *   }
- *
- * Will drop all the "undefined" types. In this case, only "e":
- *
- *   {
- *     a: string;
- *     b: number | undefined;
- *     c: null | undefined;
- *     d: null;
- *   }
- *
- */
-type Compact<T> = { [K in IsDefined<T, keyof T>]: T[K] };
-
-type IsDefined<T, K extends keyof T> = K extends any
-    ? T[K] extends undefined
-        ? never
-        : K
-    : never;
-
-//
-// HACK:
-// These weird conditionals test whether TypeScript is configured with the
-// `strictNullChecks` compiler option. We use these definitions to influence
-// what's considered a "required" vs an "optional" key for the AllowImplicit
-// type.
-//
-// If strictNullChecks is false, then we should not be emitting any `?` fields
-// and consider all fields "required" because everything is optional by default
-// in that mode anyway.
-//
-type NoStrictNullChecks = undefined extends string ? 1 : undefined;
-//                        ^^^^^^^^^^^^^^^^^^^^^^^^
-type StrictNullChecks = undefined extends string ? undefined : 1;
-//                      ^^^^^^^^^^^^^^^^^^^^^^^^
-
-export type RequiredKeys<T> = keyof Compact<{
-    [K in keyof T]: undefined extends T[K] ? NoStrictNullChecks : 1;
-}>;
-
-export type OptionalKeys<T> = keyof Compact<{
-    [K in keyof T]: undefined extends T[K] ? 1 : StrictNullChecks;
-}>;
-
-/**
- * Transforms an object type, by marking all fields that contain "undefined"
- * with a question mark, i.e. allowing implicit-undefineds when
- * explicit-undefined are also allowed.
- *
- * For example, if:
- *
- *   type User = {
- *     name: string;
- *     age: number | null | undefined;
- *   }
- *
- * Then AllowImplicit<User> will become equivalent to:
- *
- *   {
- *     name: string;
- *     age?: number | null;
- *        ^
- *        Note the question mark
- *   }
- */
-type AllowImplicit<T> = { [K in RequiredKeys<T>]-?: T[K] } & {
-    [K in OptionalKeys<T>]+?: Exclude<T[K], undefined>;
-};
-
-export { AllowImplicit };

package/index.d.ts

@@ -1,38 +0,0 @@
-import { Decoder, DecoderType, Guard, GuardType } from './types';
-
-export { guard } from './guard';
-export { compose, map, predicate } from './utils';
-
-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 {
-    either,
-    either3,
-    either4,
-    either5,
-    either6,
-    either7,
-    either8,
-    either9,
-    oneOf,
-} from './either';
-export { fail } from './fail';
-export { instanceOf } from './instanceOf';
-export { json, jsonArray, jsonObject } 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 { Decoder, Guard };
-export { DecoderType, GuardType };
-export { JSONArray, JSONObject, JSONValue } from './json';
-
-export type $DecoderType<T> = DecoderType<T>; // Alias for backward compatibility

package/instanceOf.d.ts

@@ -1,3 +0,0 @@
-import { Decoder } from './types';
-
-export function instanceOf<T>(klass: new (...args: any) => T): Decoder<T>;

package/instanceOf.js

@@ -1,17 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.instanceOf = instanceOf;
-
-var _debrief = require("debrief");
-
-var _Result = require("lemons/Result");
-
-function instanceOf(klass) {
-  return function (blob) {
-    return blob instanceof klass ? (0, _Result.Ok)(blob) : (0, _Result.Err)((0, _debrief.annotate)(blob, "Must be ".concat( // $FlowFixMe[incompatible-use] - klass.name is fine?
-    klass.name, " instance")));
-  };
-}

package/json.d.ts

@@ -1,11 +0,0 @@
-import { Decoder } from './types';
-
-export type JSONValue = null | string | number | boolean | JSONObject | JSONArray;
-export interface JSONObject {
-    [key: string]: JSONValue;
-}
-export type JSONArray = JSONValue[];
-
-export const json: Decoder<JSONValue>;
-export const jsonArray: Decoder<JSONArray>;
-export const jsonObject: Decoder<JSONObject>;

package/lazy.d.ts

@@ -1,3 +0,0 @@
-import { Decoder } from './types';
-
-export function lazy<T>(decoderFn: () => Decoder<T>): Decoder<T>;

package/mapping.d.ts

@@ -1,4 +0,0 @@
-import { Decoder } from './types';
-
-export function mapping<T>(decoder: Decoder<T>): Decoder<Map<string, T>>;
-export function dict<T>(decoder: Decoder<T>): Decoder<{ [key: string]: T }>;

package/mapping.js

@@ -1,113 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.dict = dict;
-exports.mapping = mapping;
-
-var _debrief = require("debrief");
-
-var _Result = require("lemons/Result");
-
-var _object = require("./object");
-
-var _utils = require("./utils");
-
-function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
-
-function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
-
-function _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
-
-function _arrayWithHoles(arr) { if (Array.isArray(arr)) return 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(_e2) { throw _e2; }, 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(_e3) { didErr = true; err = _e3; }, 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; }
-
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
-
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
-
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-
-/**
- * Given an object, will decode a Map of string keys to whatever values.
- *
- * For example, given a decoder for a Person, we can verify a Person lookup
- * table structure (of type Map<string, Person>) like so:
- *
- *   mapping(person)
- *
- */
-function mapping(decoder) {
-  return (0, _utils.compose)(_object.pojo, // $FlowFixMe[unclear-type] (not really an issue) - deliberate use of Object here
-  function (blob) {
-    var tuples = [];
-    var errors = [];
-    Object.keys(blob).forEach(function (key) {
-      var value = blob[key];
-      var result = decoder(value);
-
-      try {
-        var okValue = result.unwrap();
-
-        if (errors.length === 0) {
-          tuples.push([key, okValue]);
-        }
-      } catch (e) {
-        /* istanbul ignore else */
-        if ((0, _debrief.isAnnotation)(e)) {
-          tuples.length = 0; // Clear the tuples array
-
-          errors.push([key, e]);
-        } else {
-          // Otherwise, simply rethrow it
-
-          /* istanbul ignore next */
-          throw e;
-        }
-      }
-    });
-
-    if (errors.length > 0) {
-      return (0, _Result.Err)((0, _debrief.annotateFields)(blob, errors));
-    } else {
-      return (0, _Result.Ok)(new Map(tuples));
-    }
-  });
-}
-
-function mapToObject(mapping) {
-  var result = _objectSpread({}, null);
-
-  var _iterator = _createForOfIteratorHelper(mapping.entries()),
-      _step;
-
-  try {
-    for (_iterator.s(); !(_step = _iterator.n()).done;) {
-      var _step$value = _slicedToArray(_step.value, 2),
-          k = _step$value[0],
-          v = _step$value[1];
-
-      result[k] = v;
-    }
-  } catch (err) {
-    _iterator.e(err);
-  } finally {
-    _iterator.f();
-  }
-
-  return result;
-}
-/**
- * Like mapping(), but returns an object rather than a Map instance.
- */
-
-
-function dict(decoder) {
-  return (0, _utils.map)(mapping(decoder), mapToObject);
-}

package/mapping.js.flow

@@ -1,71 +0,0 @@
-// @flow strict
-
-import type { Annotation } from 'debrief';
-import { annotateFields, isAnnotation } from 'debrief';
-import { Err, Ok } from 'lemons/Result';
-
-import { pojo } from './object';
-import type { Decoder } from './types';
-import { compose, map } from './utils';
-
-/**
- * Given an object, will decode a Map of string keys to whatever values.
- *
- * For example, given a decoder for a Person, we can verify a Person lookup
- * table structure (of type Map<string, Person>) like so:
- *
- *   mapping(person)
- *
- */
-export function mapping<T>(decoder: Decoder<T>): Decoder<Map<string, T>> {
-    return compose(
-        pojo,
-        // $FlowFixMe[unclear-type] (not really an issue) - deliberate use of Object here
-        (blob: Object) => {
-            let tuples: Array<[string, T]> = [];
-            let errors: Array<[string, string | Annotation]> = [];
-
-            Object.keys(blob).forEach((key: string) => {
-                const value: T = blob[key];
-                const result = decoder(value);
-                try {
-                    const okValue = result.unwrap();
-                    if (errors.length === 0) {
-                        tuples.push([key, okValue]);
-                    }
-                } catch (e) {
-                    /* istanbul ignore else */
-                    if (isAnnotation(e)) {
-                        tuples.length = 0; // Clear the tuples array
-                        errors.push([key, e]);
-                    } else {
-                        // Otherwise, simply rethrow it
-                        /* istanbul ignore next */
-                        throw e;
-                    }
-                }
-            });
-
-            if (errors.length > 0) {
-                return Err(annotateFields(blob, errors));
-            } else {
-                return Ok(new Map(tuples));
-            }
-        }
-    );
-}
-
-function mapToObject<T>(mapping: Map<string, T>): { [string]: T } {
-    const result: { [string]: T } = { ...null };
-    for (const [k, v] of mapping.entries()) {
-        result[k] = v;
-    }
-    return result;
-}
-
-/**
- * Like mapping(), but returns an object rather than a Map instance.
- */
-export function dict<T>(decoder: Decoder<T>): Decoder<{ [string]: T }> {
-    return map(mapping(decoder), mapToObject);
-}

package/number.d.ts

@@ -1,6 +0,0 @@
-import { Decoder } from './types';
-
-export const integer: Decoder<number>;
-export const number: Decoder<number>;
-export const positiveInteger: Decoder<number>;
-export const positiveNumber: Decoder<number>;

package/number.js

@@ -1,38 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.positiveNumber = exports.positiveInteger = exports.number = exports.integer = void 0;
-
-var _debrief = require("debrief");
-
-var _Result = require("lemons/Result");
-
-var _utils = require("./utils");
-
-var anyNumber = function anyNumber(blob) {
-  return typeof blob === 'number' && !Number.isNaN(blob) ? (0, _Result.Ok)(blob) : (0, _Result.Err)((0, _debrief.annotate)(blob, 'Must be number'));
-};
-
-var isInteger = function isInteger(n) {
-  return Number.isInteger(n);
-};
-
-var isFinite = function isFinite(n) {
-  return Number.isFinite(n);
-};
-
-var number = (0, _utils.compose)(anyNumber, (0, _utils.predicate)(isFinite, 'Number must be finite'));
-exports.number = number;
-var positiveNumber = (0, _utils.compose)(number, (0, _utils.predicate)(function (n) {
-  return n >= 0;
-}, 'Number must be positive')); // Integers
-
-exports.positiveNumber = positiveNumber;
-var integer = (0, _utils.compose)(number, (0, _utils.predicate)(isInteger, 'Number must be an integer'));
-exports.integer = integer;
-var positiveInteger = (0, _utils.compose)(integer, (0, _utils.predicate)(function (n) {
-  return n >= 0;
-}, 'Number must be positive'));
-exports.positiveInteger = positiveInteger;