decoders 2.0.5 → 2.2.0-test

package/lib/strings.js.flow

@@ -1,90 +0,0 @@
-// @flow strict
-
-import { define } from '../Decoder';
-import { either } from './unions';
-import { instanceOf } from './utilities';
-import type { Decoder } from '../Decoder';
-
-/** Match groups in this regex:
- * \1 - the scheme
- * \2 - the username/password (optional)
- * \3 - the host
- * \4 - the port (optional)
- * \5 - the path (optional)
- */
-const url_re =
-    /^([A-Za-z]{3,9}(?:[+][A-Za-z]{3,9})?):\/\/(?:([-;:&=+$,\w]+)@)?(?:([A-Za-z0-9.-]+)(?::([0-9]{2,5}))?)(\/(?:[-+~%/.,\w]*)?(?:\?[-+=&;%@.,/\w]*)?(?:#[.,!/\w]*)?)?$/;
-
-/**
- * Accepts and returns strings.
- */
-export const string: Decoder<string> = define((blob, ok, err) =>
-    typeof blob === 'string' ? ok(blob) : err('Must be string'),
-);
-
-/**
- * Like `string`, but will reject the empty string or strings containing only whitespace.
- */
-export const nonEmptyString: Decoder<string> = regex(/\S/, 'Must be non-empty string');
-
-/**
- * Accepts and returns strings that match the given regular expression.
- */
-export function regex(regex: RegExp, msg: string): Decoder<string> {
-    return string.refine((s) => regex.test(s), msg);
-}
-
-/**
- * Accepts and returns strings that are syntactically valid email addresses.
- * (This will not mean that the email address actually exist.)
- */
-export const email: Decoder<string> = regex(
-    // The almost perfect email regex, taken from https://emailregex.com/
-    /^(([^<>()[\]\\.,;:\s@"]+(\.[^<>()[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/,
-    'Must be email',
-);
-
-/**
- * Accepts strings that are valid URLs, returns the value as a URL instance.
- */
-export const url: Decoder<URL> = either(
-    regex(url_re, 'Must be URL').transform((value) => new URL(value)),
-    instanceOf(URL),
-);
-
-/**
- * Accepts strings that are valid URLs, but only HTTPS ones. Returns the value
- * as a URL instance.
- */
-export const httpsUrl: Decoder<URL> = url.refine(
-    (value) => value.protocol === 'https:',
-    'Must be an HTTPS URL',
-);
-
-/**
- * Accepts strings that are valid
- * [UUIDs](https://en.wikipedia.org/wiki/universally_unique_identifier)
- * (universally unique identifier).
- */
-export const uuid: Decoder<string> = regex(
-    /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i,
-    'Must be uuid',
-);
-
-/**
- * Like `uuid`, but only accepts
- * [UUIDv1](https://en.wikipedia.org/wiki/Universally_unique_identifier#Version_1_%28date-time_and_MAC_address%29)
- * strings.
- */
-export const uuidv1: Decoder<string> =
-    // https://en.wikipedia.org/wiki/Universally_unique_identifier#Version_1_(date-time_and_MAC_address)
-    uuid.refine((value) => value[14] === '1', 'Must be uuidv1');
-
-/**
- * Like `uuid`, but only accepts
- * [UUIDv4](https://en.wikipedia.org/wiki/Universally_unique_identifier#Version_4_%28random%29)
- * strings.
- */
-export const uuidv4: Decoder<string> =
-    // https://en.wikipedia.org/wiki/Universally_unique_identifier#Version_4_(random)
-    uuid.refine((value) => value[14] === '4', 'Must be uuidv4');

package/lib/strings.mjs

@@ -1,40 +0,0 @@
-import { define } from '../Decoder.mjs'
-import { either } from './unions.mjs'
-import { instanceOf } from './utilities.mjs'
-
-var url_re = /^([A-Za-z]{3,9}(?:[+][A-Za-z]{3,9})?):\/\/(?:([-;:&=+$,\w]+)@)?(?:([A-Za-z0-9.-]+)(?::([0-9]{2,5}))?)(\/(?:[-+~%/.,\w]*)?(?:\?[-+=&;%@.,/\w]*)?(?:#[.,!/\w]*)?)?$/
-
-export var string = define(function (blob, ok, err) {
-  return typeof blob === 'string' ? ok(blob) : err('Must be string')
-})
-
-export var nonEmptyString = regex(/\S/, 'Must be non-empty string')
-
-export function regex(regex, msg) {
-  return string.refine(function (s) {
-    return regex.test(s)
-  }, msg)
-}
-
-export var email = regex(/^(([^<>()[\]\\.,;:\s@"]+(\.[^<>()[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/, 'Must be email')
-
-export var url = either(
-  regex(url_re, 'Must be URL').transform(function (value) {
-    return new URL(value)
-  }),
-  instanceOf(URL)
-)
-
-export var httpsUrl = url.refine(function (value) {
-  return value.protocol === 'https:'
-}, 'Must be an HTTPS URL')
-
-export var uuid = regex(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i, 'Must be uuid')
-
-export var uuidv1 = uuid.refine(function (value) {
-  return value[14] === '1'
-}, 'Must be uuidv1')
-
-export var uuidv4 = uuid.refine(function (value) {
-  return value[14] === '4'
-}, 'Must be uuidv4')

package/lib/unions.d.ts

@@ -1,55 +0,0 @@
-import { Decoder, DecoderType, Scalar } from '../Decoder';
-
-export type Values<T extends object> = T[keyof T];
-
-export type DecoderTypes<T> = T extends ReadonlyArray<Decoder<infer U>> ? U : never;
-
-/**
- * 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 function either<T extends ReadonlyArray<Decoder<any>>>(
-    ...args: T
-): Decoder<DecoderTypes<T>>;
-
-/**
- * Accepts any value that is strictly-equal (using `===`) to one of the
- * specified values.
- */
-export function oneOf<T extends Scalar>(constants: readonly T[]): Decoder<T>;
-
-/**
- * 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<O extends Record<string, Decoder<any>>>(
-    field: string,
-    mapping: O,
-): Decoder<Values<{ [key in keyof O]: DecoderType<O[key]> }>>;

package/lib/unions.js

@@ -1,82 +0,0 @@
-'use strict'
-
-exports.__esModule = true
-exports.either = void 0
-exports.oneOf = oneOf
-exports.taggedUnion = taggedUnion
-var _Decoder = require('../Decoder')
-var _utils = require('../_utils')
-var _objects = require('./objects')
-var _utilities = require('./utilities')
-var EITHER_PREFIX = 'Either:\n'
-
-function itemize(s) {
-  return '-' + (0, _utils.indent)(s).substring(1)
-}
-
-function nest(errText) {
-  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]
-  }
-  if (decoders.length === 0) {
-    throw new Error('Pass at least one decoder to either()')
-  }
-  return (0, _Decoder.define)(function (blob, _, err) {
-    var errors = []
-    for (var _i = 0; _i < decoders.length; _i++) {
-      var result = decoders[_i].decode(blob)
-      if (result.ok) {
-        return result
-      } else {
-        errors.push(result.error)
-      }
-    }
-    var text =
-      EITHER_PREFIX +
-      errors
-        .map(function (err) {
-          return nest((0, _utils.summarize)(err).join('\n'))
-        })
-        .join('\n')
-    return err(text)
-  })
-}
-
-var 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
-    })
-    if (winner !== undefined) {
-      return ok(winner)
-    }
-    return err(
-      'Must be one of ' +
-        constants
-          .map(function (value) {
-            return JSON.stringify(value)
-          })
-          .join(', ')
-    )
-  })
-}
-
-function taggedUnion(field, mapping) {
-  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]
-  })
-  return base.peek_UNSTABLE(function (_ref) {
-    var blob = _ref[0],
-      key = _ref[1]
-    var decoder = mapping[key]
-    return decoder.decode(blob)
-  })
-}

package/lib/unions.js.flow

@@ -1,155 +0,0 @@
-// @flow strict
-
-import { define } from '../Decoder';
-import { indent, summarize } from '../_utils';
-import { object } from './objects';
-import { prep } from './utilities';
-import type { _Any } from '../_utils';
-import type { Decoder, DecodeResult, Scalar } from '../Decoder';
-
-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)}`;
-}
-
-/**
- * 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: string): string {
-    return errText.startsWith(EITHER_PREFIX)
-        ? errText.substr(EITHER_PREFIX.length)
-        : itemize(errText);
-}
-
-// prettier-ignore
-interface EitherT {
-  <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>;
-  <A, B, C, D, E, F, G>(a: Decoder<A>, b: Decoder<B>, c: Decoder<C>, d: Decoder<D>, e: Decoder<E>, f: Decoder<F>, g: Decoder<G>): Decoder<A | B | C | D | E | F | G>;
-  <A, B, C, D, E, F, G, H>(a: Decoder<A>, b: Decoder<B>, c: Decoder<C>, d: Decoder<D>, e: Decoder<E>, f: Decoder<F>, g: Decoder<G>, h: Decoder<H>): Decoder<A | B | C | D | E | F | G | H>;
-  <A, B, C, D, E, F, G, H, I>(a: Decoder<A>, b: Decoder<B>, c: Decoder<C>, d: Decoder<D>, e: Decoder<E>, f: Decoder<F>, g: Decoder<G>, h: Decoder<H>, i: Decoder<I>): Decoder<A | B | C | D | E | F | G | H | I>;
-}
-
-function _either(...decoders: $ReadOnlyArray<Decoder<mixed>>): Decoder<mixed> {
-    if (decoders.length === 0) {
-        throw new Error('Pass at least one decoder to either()');
-    }
-
-    return define((blob, _, err) => {
-        // Collect errors here along the way
-        const errors = [];
-
-        for (let i = 0; i < decoders.length; i++) {
-            const result: DecodeResult<mixed> = decoders[i].decode(blob);
-            if (result.ok) {
-                return result;
-            } else {
-                errors.push(result.error);
-            }
-        }
-
-        // Decoding all alternatives failed, return the combined error message
-        const text =
-            EITHER_PREFIX +
-            errors.map((err) => 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 const either: EitherT = (_either: _Any);
-
-/**
- * Accepts any value that is strictly-equal (using `===`) to one of the
- * specified values.
- */
-export function oneOf<T: Scalar>(constants: $ReadOnlyArray<T>): Decoder<T> {
-    return define((blob, ok, err) => {
-        const winner = constants.find((c) => c === blob);
-        if (winner !== undefined) {
-            return ok(winner);
-        }
-        return err(
-            `Must be one of ${constants
-                .map((value) => 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<O: { +[field: string]: Decoder<_Any>, ... }>(
-    field: string,
-    mapping: O,
-): Decoder<$Values<$ObjMap<O, <T>(Decoder<T>) => T>>> {
-    const base: Decoder<string> = object({
-        [field]: prep(String, oneOf(Object.keys(mapping))),
-    }).transform((o) => o[field]);
-    return base.peek_UNSTABLE(([blob, key]) => {
-        const decoder = mapping[key];
-        return decoder.decode(blob);
-    });
-}

package/lib/unions.mjs

@@ -1,75 +0,0 @@
-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)
-}
-
-function nest(errText) {
-  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]
-  }
-  if (decoders.length === 0) {
-    throw new Error('Pass at least one decoder to either()')
-  }
-  return define(function (blob, _, err) {
-    var errors = []
-    for (var _i = 0; _i < decoders.length; _i++) {
-      var result = decoders[_i].decode(blob)
-      if (result.ok) {
-        return result
-      } else {
-        errors.push(result.error)
-      }
-    }
-    var text =
-      EITHER_PREFIX +
-      errors
-        .map(function (err) {
-          return nest(summarize(err).join('\n'))
-        })
-        .join('\n')
-    return err(text)
-  })
-}
-
-export var either = _either
-
-export function oneOf(constants) {
-  return define(function (blob, ok, err) {
-    var winner = constants.find(function (c) {
-      return c === blob
-    })
-    if (winner !== undefined) {
-      return ok(winner)
-    }
-    return err(
-      'Must be one of ' +
-        constants
-          .map(function (value) {
-            return JSON.stringify(value)
-          })
-          .join(', ')
-    )
-  })
-}
-
-export function taggedUnion(field, mapping) {
-  var _object
-  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)
-  })
-}

package/lib/utilities.d.ts

@@ -1,40 +0,0 @@
-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<K extends Klass<any>>(klass: K): Decoder<Instance<K>>;
-
-/**
- * Lazily evaluate the given decoder. This is useful to build self-referential
- * types for recursive data structures.
- */
-export function lazy<T>(decoderFn: () => Decoder<T>): Decoder<T>;
-
-/**
- * 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<T>(
-    mapperFn: (blob: unknown) => unknown,
-    decoder: Decoder<T>,
-): Decoder<T>;
-
-/**
- * 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: string): Decoder<never>;
-
-/**
- * Alias of never().
- */
-export function fail(msg: string): Decoder<never>;

package/lib/utilities.js

@@ -1,44 +0,0 @@
-'use strict'
-
-exports.__esModule = true
-exports.fail = void 0
-exports.instanceOf = instanceOf
-exports.lazy = lazy
-exports.never = never
-exports.prep = prep
-var _annotate = require('../annotate')
-var _Decoder = require('../Decoder')
-
-function instanceOf(klass) {
-  return (0, _Decoder.define)(function (blob, ok, err) {
-    return blob instanceof klass ? ok(blob) : err('Must be ' + klass.name + ' instance')
-  })
-}
-
-function lazy(decoderFn) {
-  return (0, _Decoder.define)(function (blob) {
-    return decoderFn().decode(blob)
-  })
-}
-
-function prep(mapperFn, decoder) {
-  return (0, _Decoder.define)(function (originalInput, _, err) {
-    var blob
-    try {
-      blob = mapperFn(originalInput)
-    } catch (e) {
-      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))
-  })
-}
-
-function never(msg) {
-  return (0, _Decoder.define)(function (_, __, err) {
-    return err(msg)
-  })
-}
-
-var fail = never
-exports.fail = fail

package/lib/utilities.js.flow

@@ -1,65 +0,0 @@
-// @flow strict
-
-import { annotate } from '../annotate';
-import { define } from '../Decoder';
-import type { Decoder } from '../Decoder';
-
-/**
- * Accepts any value that is an ``instanceof`` the given class.
- */
-export function instanceOf<T>(klass: Class<T>): Decoder<T> {
-    return define((blob, ok, err) =>
-        blob instanceof klass
-            ? ok(blob)
-            : err(
-                  `Must be ${
-                      // $FlowFixMe[incompatible-use] - klass.name is fine?
-                      klass.name
-                  } instance`,
-              ),
-    );
-}
-
-/**
- * Lazily evaluate the given decoder. This is useful to build self-referential
- * types for recursive data structures.
- */
-export function lazy<T>(decoderFn: () => Decoder<T>): Decoder<T> {
-    return define((blob) => 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<T>(mapperFn: (mixed) => mixed, decoder: Decoder<T>): Decoder<T> {
-    return define((originalInput, _, err) => {
-        let blob;
-        try {
-            blob = mapperFn(originalInput);
-        } catch (e) {
-            return err(annotate(originalInput, e.message));
-        }
-
-        const r = decoder.decode(blob);
-        return r.ok ? r : err(annotate(originalInput, r.error.text));
-        //                             ^^^^^^^^^^^^^
-        //                             Annotates the _original_ input value
-        //                             (instead of echoing back blob)
-    });
-}
-
-/**
- * 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: string): Decoder<empty> {
-    return define((_, __, err) => err(msg));
-}
-
-/**
- * Alias of never().
- */
-export const fail: (msg: string) => Decoder<empty> = never;

package/lib/utilities.mjs

@@ -1,35 +0,0 @@
-import { annotate } from '../annotate.mjs'
-import { define } from '../Decoder.mjs'
-
-export function instanceOf(klass) {
-  return define(function (blob, ok, err) {
-    return blob instanceof klass ? ok(blob) : err('Must be ' + klass.name + ' instance')
-  })
-}
-
-export function lazy(decoderFn) {
-  return define(function (blob) {
-    return decoderFn().decode(blob)
-  })
-}
-
-export function prep(mapperFn, decoder) {
-  return define(function (originalInput, _, err) {
-    var blob
-    try {
-      blob = mapperFn(originalInput)
-    } catch (e) {
-      return err(annotate(originalInput, e.message))
-    }
-    var r = decoder.decode(blob)
-    return r.ok ? r : err(annotate(originalInput, r.error.text))
-  })
-}
-
-export function never(msg) {
-  return define(function (_, __, err) {
-    return err(msg)
-  })
-}
-
-export var fail = never