decoders 2.0.0-beta8 → 2.0.1

package/core/number.js

@@ -1,36 +0,0 @@
-"use strict";
-
-exports.__esModule = true;
-exports.positiveNumber = exports.positiveInteger = exports.number = exports.integer = void 0;
-
-var _annotate = require("../annotate");
-
-var _result = require("../result");
-
-var _composition = require("./composition");
-
-var anyNumber = function anyNumber(blob) {
-  return typeof blob === 'number' && !Number.isNaN(blob) ? (0, _result.ok)(blob) : (0, _result.err)((0, _annotate.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, _composition.predicate)(anyNumber, isFinite, 'Number must be finite');
-exports.number = number;
-var positiveNumber = (0, _composition.predicate)(number, function (n) {
-  return n >= 0;
-}, 'Number must be positive'); // Integers
-
-exports.positiveNumber = positiveNumber;
-var integer = (0, _composition.predicate)(number, isInteger, 'Number must be an integer');
-exports.integer = integer;
-var positiveInteger = (0, _composition.predicate)(integer, function (n) {
-  return n >= 0;
-}, 'Number must be positive');
-exports.positiveInteger = positiveInteger;

package/core/number.js.flow

@@ -1,40 +0,0 @@
-// @flow strict
-
-import { annotate } from '../annotate';
-import { err, ok } from '../result';
-import { predicate } from './composition';
-import type { Decoder } from '../_types';
-
-const anyNumber: Decoder<number> = (blob: mixed) => {
-    return typeof blob === 'number' && !Number.isNaN(blob)
-        ? ok(blob)
-        : err(annotate(blob, 'Must be number'));
-};
-
-const isInteger = (n: number) => Number.isInteger(n);
-const isFinite = (n: number) => Number.isFinite(n);
-
-export const number: Decoder<number> = predicate(
-    anyNumber,
-    isFinite,
-    'Number must be finite',
-);
-
-export const positiveNumber: Decoder<number> = predicate(
-    number,
-    (n) => n >= 0,
-    'Number must be positive',
-);
-
-// Integers
-export const integer: Decoder<number> = predicate(
-    number,
-    isInteger,
-    'Number must be an integer',
-);
-
-export const positiveInteger: Decoder<number> = predicate(
-    integer,
-    (n) => n >= 0,
-    'Number must be positive',
-);

package/core/number.mjs

@@ -1,25 +0,0 @@
-import { annotate } from '../annotate.mjs';
-import { err, ok } from '../result.mjs';
-import { predicate } from './composition.mjs';
-
-var anyNumber = function anyNumber(blob) {
-  return typeof blob === 'number' && !Number.isNaN(blob) ? ok(blob) : err(annotate(blob, 'Must be number'));
-};
-
-var isInteger = function isInteger(n) {
-  return Number.isInteger(n);
-};
-
-var isFinite = function isFinite(n) {
-  return Number.isFinite(n);
-};
-
-export var number = predicate(anyNumber, isFinite, 'Number must be finite');
-export var positiveNumber = predicate(number, function (n) {
-  return n >= 0;
-}, 'Number must be positive'); // Integers
-
-export var integer = predicate(number, isInteger, 'Number must be an integer');
-export var positiveInteger = predicate(integer, function (n) {
-  return n >= 0;
-}, 'Number must be positive');

package/core/object.d.ts

@@ -1,33 +0,0 @@
-import { Decoder, DecoderType } from '../_types';
-import { AllowImplicit } from './_helpers';
-
-export type ObjectDecoderType<T> = AllowImplicit<{
-    [key in keyof T]: DecoderType<T[key]>;
-}>;
-
-export const pojo: Decoder<{ [key: string]: unknown }>;
-
-export function object<O extends { [key: string]: Decoder<any> }>(
-    mapping: O,
-): Decoder<{ [K in keyof ObjectDecoderType<O>]: ObjectDecoderType<O>[K] }>;
-//         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-//         This is basically just equivalent to:
-//             ObjectDecoderType<O>
-//
-//         But by "resolving" this with a mapped type, we remove the helper
-//         type names from the inferred type here, making this much easier to
-//         work with while developing.
-
-export function exact<O extends { [key: string]: Decoder<any> }>(
-    mapping: O,
-): Decoder<{ [K in keyof ObjectDecoderType<O>]: ObjectDecoderType<O>[K] }>;
-//         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-//         Ditto (see above)
-
-export function inexact<O extends { [key: string]: Decoder<any> }>(
-    mapping: O,
-): Decoder<
-    { [K in keyof ObjectDecoderType<O>]: ObjectDecoderType<O>[K] } & {
-        [extra: string]: unknown;
-    }
->;

package/core/object.js

@@ -1,190 +0,0 @@
-"use strict";
-
-exports.__esModule = true;
-exports.exact = exact;
-exports.inexact = inexact;
-exports.object = object;
-exports.pojo = void 0;
-
-var _annotate = require("../annotate");
-
-var _composition = require("./composition");
-
-var _result = require("../result");
-
-function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
-
-function isPojo(o) {
-  return o !== null && o !== undefined && typeof o === 'object' && // This still seems to be the only reliable way to determine whether
-  // something is a pojo... ¯\_(ツ)_/¯
-  // $FlowFixMe[method-unbinding]
-  Object.prototype.toString.call(o) === '[object Object]';
-}
-
-function subtract(xs, ys) {
-  var result = new Set();
-  xs.forEach(function (x) {
-    if (!ys.has(x)) {
-      result.add(x);
-    }
-  });
-  return result;
-}
-
-var pojo = function pojo(blob) {
-  return isPojo(blob) ? (0, _result.ok)( // NOTE:
-  // Since Flow 0.98, typeof o === 'object' refines to
-  //     {| +[string]: mixed |}
-  // instead of
-  //     {| [string]: mixed |}
-  //
-  // For rationale, see https://github.com/facebook/flow/issues/7685.
-  // In this case, we don't want to output a read-only version of
-  // the object 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 Object to a writeable one in ES6 seems
-  // to be to use object-spread. (Going off this benchmark:
-  // https://thecodebarbarian.com/object-assign-vs-object-spread.html)
-  _extends({}, blob)) : (0, _result.err)((0, _annotate.annotate)(blob, 'Must be an object'));
-};
-/**
- * Given a mapping of fields-to-decoders, builds a decoder for an object type.
- *
- * For example, given decoders for a number and a string, we can construct an
- * "object description" like so:
- *
- *   { id: number, name: string }
- *
- * Which is of type:
- *
- *   { id: Decoder<number>, name: Decoder<string> }
- *
- * Passing this to object() will produce the following return type:
- *
- *   Decoder<{ id: number, name: string }>
- *
- * Put simply: it'll "peel off" all of the nested Decoders, puts them together
- * in an object, and wraps it in a Decoder<...>.
- */
-
-
-exports.pojo = pojo;
-
-function object(mapping) {
-  var known = new Set(Object.keys(mapping));
-  return (0, _composition.compose)(pojo, function (blob) {
-    var actual = new Set(Object.keys(blob)); // At this point, "missing" will also include all fields that may
-    // validly be optional.  We'll let the underlying decoder decide and
-    // remove the key from this missing set if the decoder accepts the
-    // value.
-
-    var missing = subtract(known, actual);
-    var record = {};
-    var errors = null;
-    Object.keys(mapping).forEach(function (key) {
-      var decoder = mapping[key];
-      var rawValue = blob[key];
-      var result = decoder(rawValue);
-
-      if (result.type === 'ok') {
-        var value = result.value;
-
-        if (value !== undefined) {
-          record[key] = value;
-        } // If this succeeded, remove the key from the missing keys
-        // tracker
-
-
-        missing["delete"](key);
-      } else {
-        var ann = result.error; // Keep track of the annotation, but don't return just yet. We
-        // want to collect more error information.
-
-        if (rawValue === undefined) {
-          // Explicitly add it to the missing set if the value is
-          // undefined.  This covers explicit undefineds to be
-          // treated the same as implicit undefineds (aka missing
-          // keys).
-          missing.add(key);
-        } else {
-          if (errors === null) {
-            errors = {};
-          }
-
-          errors[key] = ann;
-        }
-      }
-    }); // Deal with errors now. There are two classes of errors we want to
-    // report.  First of all, we want to report any inline errors in this
-    // object.  Lastly, any fields that are missing should be annotated on
-    // the outer object itself.
-
-    if (errors || missing.size > 0) {
-      var objAnn = (0, _annotate.annotateObject)(blob);
-
-      if (errors) {
-        objAnn = (0, _annotate.merge)(objAnn, errors);
-      }
-
-      if (missing.size > 0) {
-        var errMsg = Array.from(missing).map(function (key) {
-          return "\"" + key + "\"";
-        }).join(', ');
-        var pluralized = missing.size > 1 ? 'keys' : 'key';
-        objAnn = (0, _annotate.updateText)(objAnn, "Missing " + pluralized + ": " + errMsg);
-      }
-
-      return (0, _result.err)(objAnn);
-    }
-
-    return (0, _result.ok)(record);
-  });
-}
-
-function exact(mapping) {
-  // Check the inputted object for any superfluous keys
-  var allowed = new Set(Object.keys(mapping));
-  var checked = (0, _composition.compose)(pojo, function (blob) {
-    var actual = new Set(Object.keys(blob));
-    var superfluous = subtract(actual, allowed);
-
-    if (superfluous.size > 0) {
-      return (0, _result.err)((0, _annotate.annotate)(blob, "Superfluous keys: " + Array.from(superfluous).join(', ')));
-    }
-
-    return (0, _result.ok)(blob);
-  }); // Defer to the "object" decoder for doing the real decoding work.  Since
-  // we made sure there are no superfluous keys in this structure, it's now
-  // safe to force-cast it to an $Exact<> type.
-
-  var decoder = object(mapping);
-  return (0, _composition.compose)(checked, decoder);
-}
-
-function inexact(mapping) {
-  return (0, _composition.compose)(pojo, function (blob) {
-    var allkeys = new Set(Object.keys(blob));
-    var decoder = (0, _composition.map)(object(mapping), function (safepart) {
-      var safekeys = new Set(Object.keys(mapping)); // To account for hard-coded keys that aren't part of the input
-
-      safekeys.forEach(function (k) {
-        return allkeys.add(k);
-      });
-      var rv = {};
-      allkeys.forEach(function (k) {
-        if (safekeys.has(k)) {
-          var value = safepart[k];
-
-          if (value !== undefined) {
-            rv[k] = value;
-          }
-        } else {
-          rv[k] = blob[k];
-        }
-      });
-      return rv;
-    });
-    return decoder(blob);
-  });
-}

package/core/object.js.flow

@@ -1,203 +0,0 @@
-// @flow strict
-
-import { annotate, annotateObject, merge, updateText } from '../annotate';
-import { compose, map } from './composition';
-import { err, ok } from '../result';
-import type { Annotation } from '../annotate';
-import type { Decoder, DecoderType } from '../_types';
-
-// $FlowFixMe[unclear-type] (not really an issue) - deliberate use of `any` - not sure how we should get rid of this
-type AnyDecoder = any;
-
-// $FlowFixMe[unclear-type] (not really an issue) - deliberately casting
-type cast = any;
-
-function isPojo(o: mixed): boolean %checks {
-    return (
-        o !== null &&
-        o !== undefined &&
-        typeof o === 'object' &&
-        // This still seems to be the only reliable way to determine whether
-        // something is a pojo... ¯\_(ツ)_/¯
-        // $FlowFixMe[method-unbinding]
-        Object.prototype.toString.call(o) === '[object Object]'
-    );
-}
-
-function subtract(xs: Set<string>, ys: Set<string>): Set<string> {
-    const result = new Set();
-    xs.forEach((x) => {
-        if (!ys.has(x)) {
-            result.add(x);
-        }
-    });
-    return result;
-}
-
-export const pojo: Decoder<{| [string]: mixed |}> = (blob: mixed) => {
-    return isPojo(blob)
-        ? ok(
-              // NOTE:
-              // Since Flow 0.98, typeof o === 'object' refines to
-              //     {| +[string]: mixed |}
-              // instead of
-              //     {| [string]: mixed |}
-              //
-              // For rationale, see https://github.com/facebook/flow/issues/7685.
-              // In this case, we don't want to output a read-only version of
-              // the object 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 Object to a writeable one in ES6 seems
-              // to be to use object-spread. (Going off this benchmark:
-              // https://thecodebarbarian.com/object-assign-vs-object-spread.html)
-              { ...blob },
-          )
-        : err(annotate(blob, 'Must be an object'));
-};
-
-/**
- * Given a mapping of fields-to-decoders, builds a decoder for an object type.
- *
- * For example, given decoders for a number and a string, we can construct an
- * "object description" like so:
- *
- *   { id: number, name: string }
- *
- * Which is of type:
- *
- *   { id: Decoder<number>, name: Decoder<string> }
- *
- * Passing this to object() will produce the following return type:
- *
- *   Decoder<{ id: number, name: string }>
- *
- * Put simply: it'll "peel off" all of the nested Decoders, puts them together
- * in an object, and wraps it in a Decoder<...>.
- */
-export function object<O: { +[field: string]: AnyDecoder, ... }>(
-    mapping: O,
-): Decoder<$ObjMap<O, DecoderType>> {
-    const known = new Set(Object.keys(mapping));
-    return compose(pojo, (blob: { +[string]: mixed }) => {
-        const actual = new Set(Object.keys(blob));
-
-        // At this point, "missing" will also include all fields that may
-        // validly be optional.  We'll let the underlying decoder decide and
-        // remove the key from this missing set if the decoder accepts the
-        // value.
-        const missing = subtract(known, actual);
-
-        let record = {};
-        let errors: { [key: string]: Annotation } | null = null;
-
-        Object.keys(mapping).forEach((key) => {
-            const decoder = mapping[key];
-            const rawValue = blob[key];
-            const result = decoder(rawValue);
-
-            if (result.type === 'ok') {
-                const value = result.value;
-                if (value !== undefined) {
-                    record[key] = value;
-                }
-
-                // If this succeeded, remove the key from the missing keys
-                // tracker
-                missing.delete(key);
-            } else {
-                const ann = result.error;
-
-                // Keep track of the annotation, but don't return just yet. We
-                // want to collect more error information.
-                if (rawValue === undefined) {
-                    // Explicitly add it to the missing set if the value is
-                    // undefined.  This covers explicit undefineds to be
-                    // treated the same as implicit undefineds (aka missing
-                    // keys).
-                    missing.add(key);
-                } else {
-                    if (errors === null) {
-                        errors = {};
-                    }
-                    errors[key] = ann;
-                }
-            }
-        });
-
-        // Deal with errors now. There are two classes of errors we want to
-        // report.  First of all, we want to report any inline errors in this
-        // object.  Lastly, any fields that are missing should be annotated on
-        // the outer object itself.
-        if (errors || missing.size > 0) {
-            let objAnn = annotateObject(blob);
-
-            if (errors) {
-                objAnn = merge(objAnn, errors);
-            }
-
-            if (missing.size > 0) {
-                const errMsg = Array.from(missing)
-                    .map((key) => `"${key}"`)
-                    .join(', ');
-                const pluralized = missing.size > 1 ? 'keys' : 'key';
-                objAnn = updateText(objAnn, `Missing ${pluralized}: ${errMsg}`);
-            }
-
-            return err(objAnn);
-        }
-
-        return ok(record);
-    });
-}
-
-export function exact<O: { +[field: string]: AnyDecoder, ... }>(
-    mapping: O,
-): Decoder<$ObjMap<$Exact<O>, DecoderType>> {
-    // Check the inputted object for any superfluous keys
-    const allowed = new Set(Object.keys(mapping));
-    const checked = compose(pojo, (blob: {| [string]: mixed |}) => {
-        const actual = new Set(Object.keys(blob));
-        const superfluous = subtract(actual, allowed);
-        if (superfluous.size > 0) {
-            return err(
-                annotate(blob, `Superfluous keys: ${Array.from(superfluous).join(', ')}`),
-            );
-        }
-        return ok(blob);
-    });
-
-    // Defer to the "object" decoder for doing the real decoding work.  Since
-    // we made sure there are no superfluous keys in this structure, it's now
-    // safe to force-cast it to an $Exact<> type.
-    const decoder = ((object(mapping): cast): Decoder<$ObjMap<$Exact<O>, DecoderType>>);
-    return compose(checked, decoder);
-}
-
-export function inexact<O: { +[field: string]: AnyDecoder }>(
-    mapping: O,
-): Decoder<$ObjMap<O, DecoderType> & { +[string]: mixed }> {
-    return compose(pojo, (blob: {| [string]: mixed |}) => {
-        const allkeys = new Set(Object.keys(blob));
-        const decoder = map(object(mapping), (safepart: $ObjMap<O, DecoderType>) => {
-            const safekeys = new Set(Object.keys(mapping));
-
-            // To account for hard-coded keys that aren't part of the input
-            safekeys.forEach((k) => allkeys.add(k));
-
-            const rv = {};
-            allkeys.forEach((k) => {
-                if (safekeys.has(k)) {
-                    const value = safepart[k];
-                    if (value !== undefined) {
-                        rv[k] = value;
-                    }
-                } else {
-                    rv[k] = blob[k];
-                }
-            });
-            return rv;
-        });
-        return decoder(blob);
-    });
-}