decoders 2.0.0 → 2.0.1

package/lib/unions.js

@@ -1,160 +1,96 @@
-"use strict";
+'use strict'
 
-exports.__esModule = true;
-exports.either = void 0;
-exports.oneOf = oneOf;
-exports.taggedUnion = taggedUnion;
+exports.__esModule = true
+exports.either = void 0
+exports.oneOf = oneOf
+exports.taggedUnion = taggedUnion
 
-var _Decoder = require("../Decoder");
+var _Decoder = require('../Decoder')
 
-var _utils = require("../_utils");
+var _utils = require('../_utils')
 
-var _objects = require("./objects");
+var _objects = require('./objects')
 
-var _utilities = require("./utilities");
+var _utilities = require('./utilities')
 
-var EITHER_PREFIX = 'Either:\n';
-/**
- * Indents and adds a dash in front of this (potentially multiline) string.
- */
+var EITHER_PREFIX = 'Either:\n'
 
 function itemize(s) {
-  return '-' + (0, _utils.indent)(s).substring(1);
+  return '-' + (0, _utils.indent)(s).substring(1)
 }
-/**
- * Nests another error as an item under a new-to-be-created "Either error". If
- * the given subitem already is an "Either error" of itself, don't indent, but
- * just "inject" its items at the same error level, for nicely flattened either
- * expressions.
- *
- * Avoids:
- *
- *     Either:
- *     - Either:
- *       - Must be P
- *       - Either:
- *         - Must be Q
- *         - Must be R
- *     - Must be S
- *
- * And "flattens" these to:
- *
- *     Either:
- *     - Must be P
- *     - Must be Q
- *     - Must be R
- *     - Must be S
- *
- */
-
 
 function nest(errText) {
-  return errText.startsWith(EITHER_PREFIX) ? errText.substr(EITHER_PREFIX.length) : itemize(errText);
-} // prettier-ignore
-
+  return errText.startsWith(EITHER_PREFIX) ? errText.substr(EITHER_PREFIX.length) : itemize(errText)
+}
 
 function _either() {
   for (var _len = arguments.length, decoders = new Array(_len), _key = 0; _key < _len; _key++) {
-    decoders[_key] = arguments[_key];
+    decoders[_key] = arguments[_key]
   }
 
   if (decoders.length === 0) {
-    throw new Error('Pass at least one decoder to either()');
+    throw new Error('Pass at least one decoder to either()')
   }
 
   return (0, _Decoder.define)(function (blob, _, err) {
-    // Collect errors here along the way
-    var errors = [];
+    var errors = []
 
     for (var _i = 0; _i < decoders.length; _i++) {
-      var result = decoders[_i].decode(blob);
+      var result = decoders[_i].decode(blob)
 
       if (result.ok) {
-        return result;
+        return result
       } else {
-        errors.push(result.error);
+        errors.push(result.error)
       }
-    } // Decoding all alternatives failed, return the combined error message
-
+    }
 
-    var text = EITHER_PREFIX + errors.map(function (err) {
-      return nest((0, _utils.summarize)(err).join('\n'));
-    }).join('\n');
-    return err(text);
-  });
+    var text =
+      EITHER_PREFIX +
+      errors
+        .map(function (err) {
+          return nest((0, _utils.summarize)(err).join('\n'))
+        })
+        .join('\n')
+    return err(text)
+  })
 }
-/**
- * Accepts values accepted by any of the given decoders.
- *
- * The decoders are tried on the input one by one, in the given order. The
- * first one that accepts the input "wins". If all decoders reject the input,
- * the input gets rejected.
- */
-
 
-var either = _either;
-/**
- * Accepts any value that is strictly-equal (using `===`) to one of the
- * specified values.
- */
+var either = _either
 
-exports.either = either;
+exports.either = either
 
 function oneOf(constants) {
   return (0, _Decoder.define)(function (blob, ok, err) {
     var winner = constants.find(function (c) {
-      return c === blob;
-    });
+      return c === blob
+    })
 
     if (winner !== undefined) {
-      return ok(winner);
+      return ok(winner)
     }
 
-    return err("Must be one of " + constants.map(function (value) {
-      return JSON.stringify(value);
-    }).join(', '));
-  });
+    return err(
+      'Must be one of ' +
+        constants
+          .map(function (value) {
+            return JSON.stringify(value)
+          })
+          .join(', ')
+    )
+  })
 }
-/**
- * If you are decoding tagged unions you may want to use the `taggedUnion()`
- * decoder instead of the general purpose `either()` decoder to get better
- * error messages and better performance.
- *
- * This decoder is optimized for [tagged
- * unions](https://en.wikipedia.org/wiki/Tagged_union), i.e. a union of
- * objects where one field is used as the discriminator.
- *
- * ```ts
- * const A = object({ tag: constant('A'), foo: string });
- * const B = object({ tag: constant('B'), bar: number });
- *
- * const AorB = taggedUnion('tag', { A, B });
- * //                        ^^^
- * ```
- *
- * Decoding now works in two steps:
- *
- * 1. Look at the `'tag'` field in the incoming object (this is the field
- *    that decides which decoder will be used)
- * 2. If the value is `'A'`, then decoder `A` will be used. If it's `'B'`, then
- *    decoder `B` will be used. Otherwise, this will fail.
- *
- * This is effectively equivalent to `either(A, B)`, but will provide better
- * error messages and is more performant at runtime because it doesn't have to
- * try all decoders one by one.
- */
-
 
 function taggedUnion(field, mapping) {
-  var _object;
+  var _object
 
-  var base = (0, _objects.object)((_object = {}, _object[field] = (0, _utilities.prep)(String, oneOf(Object.keys(mapping))), _object)).transform(function (o) {
-    return o[field];
-  });
+  var base = (0, _objects.object)(((_object = {}), (_object[field] = (0, _utilities.prep)(String, oneOf(Object.keys(mapping)))), _object)).transform(function (o) {
+    return o[field]
+  })
   return base.peek_UNSTABLE(function (_ref) {
     var blob = _ref[0],
-        key = _ref[1];
-    var decoder = mapping[key];
-    return decoder.decode(blob);
-  });
-}
+      key = _ref[1]
+    var decoder = mapping[key]
+    return decoder.decode(blob)
+  })
+}

package/lib/unions.js.flow

@@ -13,7 +13,7 @@ const EITHER_PREFIX = 'Either:\n';
  * Indents and adds a dash in front of this (potentially multiline) string.
  */
 function itemize(s: string): string {
-    return '-' + indent(s).substring(1);
+    return `-${indent(s).substring(1)}`;
 }
 
 /**

package/lib/unions.mjs

@@ -1,146 +1,83 @@
-import { define } from '../Decoder.mjs';
-import { indent, summarize } from '../_utils.mjs';
-import { object } from './objects.mjs';
-import { prep } from './utilities.mjs';
-var EITHER_PREFIX = 'Either:\n';
-/**
- * Indents and adds a dash in front of this (potentially multiline) string.
- */
+import { define } from '../Decoder.mjs'
+import { indent, summarize } from '../_utils.mjs'
+import { object } from './objects.mjs'
+import { prep } from './utilities.mjs'
+var EITHER_PREFIX = 'Either:\n'
 
 function itemize(s) {
-  return '-' + indent(s).substring(1);
+  return '-' + indent(s).substring(1)
 }
-/**
- * Nests another error as an item under a new-to-be-created "Either error". If
- * the given subitem already is an "Either error" of itself, don't indent, but
- * just "inject" its items at the same error level, for nicely flattened either
- * expressions.
- *
- * Avoids:
- *
- *     Either:
- *     - Either:
- *       - Must be P
- *       - Either:
- *         - Must be Q
- *         - Must be R
- *     - Must be S
- *
- * And "flattens" these to:
- *
- *     Either:
- *     - Must be P
- *     - Must be Q
- *     - Must be R
- *     - Must be S
- *
- */
-
 
 function nest(errText) {
-  return errText.startsWith(EITHER_PREFIX) ? errText.substr(EITHER_PREFIX.length) : itemize(errText);
-} // prettier-ignore
-
+  return errText.startsWith(EITHER_PREFIX) ? errText.substr(EITHER_PREFIX.length) : itemize(errText)
+}
 
 function _either() {
   for (var _len = arguments.length, decoders = new Array(_len), _key = 0; _key < _len; _key++) {
-    decoders[_key] = arguments[_key];
+    decoders[_key] = arguments[_key]
   }
 
   if (decoders.length === 0) {
-    throw new Error('Pass at least one decoder to either()');
+    throw new Error('Pass at least one decoder to either()')
   }
 
   return define(function (blob, _, err) {
-    // Collect errors here along the way
-    var errors = [];
+    var errors = []
 
     for (var _i = 0; _i < decoders.length; _i++) {
-      var result = decoders[_i].decode(blob);
+      var result = decoders[_i].decode(blob)
 
       if (result.ok) {
-        return result;
+        return result
       } else {
-        errors.push(result.error);
+        errors.push(result.error)
       }
-    } // Decoding all alternatives failed, return the combined error message
-
+    }
 
-    var text = EITHER_PREFIX + errors.map(function (err) {
-      return nest(summarize(err).join('\n'));
-    }).join('\n');
-    return err(text);
-  });
+    var text =
+      EITHER_PREFIX +
+      errors
+        .map(function (err) {
+          return nest(summarize(err).join('\n'))
+        })
+        .join('\n')
+    return err(text)
+  })
 }
-/**
- * Accepts values accepted by any of the given decoders.
- *
- * The decoders are tried on the input one by one, in the given order. The
- * first one that accepts the input "wins". If all decoders reject the input,
- * the input gets rejected.
- */
-
 
-export var either = _either;
-/**
- * Accepts any value that is strictly-equal (using `===`) to one of the
- * specified values.
- */
+export var either = _either
 
 export function oneOf(constants) {
   return define(function (blob, ok, err) {
     var winner = constants.find(function (c) {
-      return c === blob;
-    });
+      return c === blob
+    })
 
     if (winner !== undefined) {
-      return ok(winner);
+      return ok(winner)
     }
 
-    return err("Must be one of " + constants.map(function (value) {
-      return JSON.stringify(value);
-    }).join(', '));
-  });
+    return err(
+      'Must be one of ' +
+        constants
+          .map(function (value) {
+            return JSON.stringify(value)
+          })
+          .join(', ')
+    )
+  })
 }
-/**
- * If you are decoding tagged unions you may want to use the `taggedUnion()`
- * decoder instead of the general purpose `either()` decoder to get better
- * error messages and better performance.
- *
- * This decoder is optimized for [tagged
- * unions](https://en.wikipedia.org/wiki/Tagged_union), i.e. a union of
- * objects where one field is used as the discriminator.
- *
- * ```ts
- * const A = object({ tag: constant('A'), foo: string });
- * const B = object({ tag: constant('B'), bar: number });
- *
- * const AorB = taggedUnion('tag', { A, B });
- * //                        ^^^
- * ```
- *
- * Decoding now works in two steps:
- *
- * 1. Look at the `'tag'` field in the incoming object (this is the field
- *    that decides which decoder will be used)
- * 2. If the value is `'A'`, then decoder `A` will be used. If it's `'B'`, then
- *    decoder `B` will be used. Otherwise, this will fail.
- *
- * This is effectively equivalent to `either(A, B)`, but will provide better
- * error messages and is more performant at runtime because it doesn't have to
- * try all decoders one by one.
- */
 
 export function taggedUnion(field, mapping) {
-  var _object;
+  var _object
 
-  var base = object((_object = {}, _object[field] = prep(String, oneOf(Object.keys(mapping))), _object)).transform(function (o) {
-    return o[field];
-  });
+  var base = object(((_object = {}), (_object[field] = prep(String, oneOf(Object.keys(mapping)))), _object)).transform(function (o) {
+    return o[field]
+  })
   return base.peek_UNSTABLE(function (_ref) {
     var blob = _ref[0],
-        key = _ref[1];
-    var decoder = mapping[key];
-    return decoder.decode(blob);
-  });
-}
+      key = _ref[1]
+    var decoder = mapping[key]
+    return decoder.decode(blob)
+  })
+}

package/lib/utilities.d.ts

@@ -1,9 +1,15 @@
 import { Decoder } from '../Decoder';
 
+export interface Klass<T> extends Function {
+    new (...args: readonly any[]): T;
+}
+
+export type Instance<K> = K extends Klass<infer T> ? T : never;
+
 /**
  * Accepts any value that is an ``instanceof`` the given class.
  */
-export function instanceOf<T>(klass: new (...args: readonly any[]) => T): Decoder<T>;
+export function instanceOf<K extends Klass<any>>(klass: K): Decoder<Instance<K>>;
 
 /**
  * Lazily evaluate the given decoder. This is useful to build self-referential

package/lib/utilities.js

@@ -1,75 +1,48 @@
-"use strict";
+'use strict'
 
-exports.__esModule = true;
-exports.fail = void 0;
-exports.instanceOf = instanceOf;
-exports.lazy = lazy;
-exports.never = never;
-exports.prep = prep;
+exports.__esModule = true
+exports.fail = void 0
+exports.instanceOf = instanceOf
+exports.lazy = lazy
+exports.never = never
+exports.prep = prep
 
-var _annotate = require("../annotate");
+var _annotate = require('../annotate')
 
-var _Decoder = require("../Decoder");
+var _Decoder = require('../Decoder')
 
-/**
- * Accepts any value that is an ``instanceof`` the given class.
- */
 function instanceOf(klass) {
   return (0, _Decoder.define)(function (blob, ok, err) {
-    return blob instanceof klass ? ok(blob) : err("Must be " + // $FlowFixMe[incompatible-use] - klass.name is fine?
-    klass.name + " instance");
-  });
+    return blob instanceof klass ? ok(blob) : err('Must be ' + klass.name + ' instance')
+  })
 }
-/**
- * Lazily evaluate the given decoder. This is useful to build self-referential
- * types for recursive data structures.
- */
-
 
 function lazy(decoderFn) {
   return (0, _Decoder.define)(function (blob) {
-    return decoderFn().decode(blob);
-  });
+    return decoderFn().decode(blob)
+  })
 }
-/**
- * Pre-process the data input before passing it into the decoder. This gives
- * you the ability to arbitrarily customize the input on the fly before passing
- * it to the decoder. Of course, the input value at that point is still of
- * ``unknown`` type, so you will have to deal with that accordingly.
- */
-
 
 function prep(mapperFn, decoder) {
   return (0, _Decoder.define)(function (originalInput, _, err) {
-    var blob;
+    var blob
 
     try {
-      blob = mapperFn(originalInput);
+      blob = mapperFn(originalInput)
     } catch (e) {
-      return err((0, _annotate.annotate)(originalInput, e.message));
+      return err((0, _annotate.annotate)(originalInput, e.message))
     }
 
-    var r = decoder.decode(blob);
-    return r.ok ? r : err((0, _annotate.annotate)(originalInput, r.error.text)); //                             ^^^^^^^^^^^^^
-    //                             Annotates the _original_ input value
-    //                             (instead of echoing back blob)
-  });
+    var r = decoder.decode(blob)
+    return r.ok ? r : err((0, _annotate.annotate)(originalInput, r.error.text))
+  })
 }
-/**
- * Rejects all inputs, and always fails with the given error message. May be
- * useful for explicitly disallowing keys, or for testing purposes.
- */
-
 
 function never(msg) {
   return (0, _Decoder.define)(function (_, __, err) {
-    return err(msg);
-  });
+    return err(msg)
+  })
 }
-/**
- * Alias of never().
- */
-
 
-var fail = never;
-exports.fail = fail;
+var fail = never
+exports.fail = fail

package/lib/utilities.mjs

@@ -1,60 +1,37 @@
-import { annotate } from '../annotate.mjs';
-import { define } from '../Decoder.mjs';
+import { annotate } from '../annotate.mjs'
+import { define } from '../Decoder.mjs'
 
-/**
- * Accepts any value that is an ``instanceof`` the given class.
- */
 export function instanceOf(klass) {
   return define(function (blob, ok, err) {
-    return blob instanceof klass ? ok(blob) : err("Must be " + // $FlowFixMe[incompatible-use] - klass.name is fine?
-    klass.name + " instance");
-  });
+    return blob instanceof klass ? ok(blob) : err('Must be ' + klass.name + ' instance')
+  })
 }
-/**
- * Lazily evaluate the given decoder. This is useful to build self-referential
- * types for recursive data structures.
- */
 
 export function lazy(decoderFn) {
   return define(function (blob) {
-    return decoderFn().decode(blob);
-  });
+    return decoderFn().decode(blob)
+  })
 }
-/**
- * Pre-process the data input before passing it into the decoder. This gives
- * you the ability to arbitrarily customize the input on the fly before passing
- * it to the decoder. Of course, the input value at that point is still of
- * ``unknown`` type, so you will have to deal with that accordingly.
- */
 
 export function prep(mapperFn, decoder) {
   return define(function (originalInput, _, err) {
-    var blob;
+    var blob
 
     try {
-      blob = mapperFn(originalInput);
+      blob = mapperFn(originalInput)
     } catch (e) {
-      return err(annotate(originalInput, e.message));
+      return err(annotate(originalInput, e.message))
     }
 
-    var r = decoder.decode(blob);
-    return r.ok ? r : err(annotate(originalInput, r.error.text)); //                             ^^^^^^^^^^^^^
-    //                             Annotates the _original_ input value
-    //                             (instead of echoing back blob)
-  });
+    var r = decoder.decode(blob)
+    return r.ok ? r : err(annotate(originalInput, r.error.text))
+  })
 }
-/**
- * Rejects all inputs, and always fails with the given error message. May be
- * useful for explicitly disallowing keys, or for testing purposes.
- */
 
 export function never(msg) {
   return define(function (_, __, err) {
-    return err(msg);
-  });
+    return err(msg)
+  })
 }
-/**
- * Alias of never().
- */
 
-export var fail = never;
+export var fail = never

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "decoders",
-    "version": "2.0.0",
+    "version": "2.0.1",
     "description": "Elegant and battle-tested validation library for type-safe input data (for TypeScript and Flow)",
     "license": "MIT",
     "repository": {

package/result.js

@@ -1,34 +1,21 @@
-"use strict";
+'use strict'
 
-exports.__esModule = true;
-exports.err = err;
-exports.ok = ok;
+exports.__esModule = true
+exports.err = err
+exports.ok = ok
 
-/**
- * Result <value> <error>
- *     = Ok <value>
- *     | Err <error>
- */
-
-/**
- * Create a new Result instance representing a successful computation.
- */
 function ok(value) {
   return {
     ok: true,
     value: value,
-    error: undefined
-  };
+    error: undefined,
+  }
 }
-/**
- * Create a new Result instance representing a failed computation.
- */
-
 
 function err(error) {
   return {
     ok: false,
     value: undefined,
-    error: error
-  };
-}
+    error: error,
+  }
+}