decoders 2.1.0 → 2.2.0-test2

package/lib/arrays.js.flow

@@ -1,138 +0,0 @@
-// @flow strict
-
-import { annotate } from '../annotate';
-import { define } from '../Decoder';
-import type { _Any } from '../_utils';
-import type { Annotation } from '../annotate';
-import type { Decoder, DecodeResult } from '../Decoder';
-
-/**
- * Accepts any array, but doesn't validate its items further.
- *
- * "poja" means "plain old JavaScript array", a play on `pojo()`.
- */
-export const poja: Decoder<Array<mixed>> = define((blob, ok, err) => {
-    if (!Array.isArray(blob)) {
-        return err('Must be an array');
-    }
-    return 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 array of Result instances, loop over 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
- */
-function all<T>(
-    items: $ReadOnlyArray<DecodeResult<T>>,
-    blobs: $ReadOnlyArray<mixed>,
-
-    // TODO: Make this less ugly
-    ok: (Array<T>) => DecodeResult<Array<T>>,
-    err: (Annotation) => DecodeResult<Array<T>>,
-): DecodeResult<Array<T>> {
-    const results: Array<T> = [];
-    for (let index = 0; index < items.length; ++index) {
-        const result = items[index];
-        if (result.ok) {
-            results.push(result.value);
-        } else {
-            const ann = result.error;
-
-            // Rewrite the annotation to include the index information, and inject it into the original blob
-            const clone = [...blobs];
-            clone.splice(
-                index,
-                1,
-                annotate(
-                    ann,
-                    ann.text ? `${ann.text} (at index ${index})` : `index ${index}`,
-                ),
-            );
-
-            return err(annotate(clone));
-        }
-    }
-    return ok(results);
-}
-
-/**
- * Accepts arrays of whatever the given decoder accepts.
- */
-export function array<T>(decoder: Decoder<T>): Decoder<Array<T>> {
-    return poja.then((blobs: $ReadOnlyArray<mixed>, ok, err) => {
-        const results = blobs.map(decoder.decode);
-        return all(results, blobs, ok, err);
-    });
-}
-
-/**
- * Like `array()`, but will reject arrays with 0 elements.
- */
-export function nonEmptyArray<T>(decoder: Decoder<T>): Decoder<Array<T>> {
-    return array(decoder).refine((arr) => arr.length > 0, 'Must be non-empty array');
-}
-
-/**
- * Similar to `array()`, but returns the result as an [ES6
- * Set](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set).
- */
-export function set<T>(decoder: Decoder<T>): Decoder<Set<T>> {
-    return array(decoder).transform((items) => new Set(items));
-}
-
-const ntuple = (n: number) =>
-    poja.refine((arr) => arr.length === n, `Must be a ${n}-tuple`);
-
-// prettier-ignore
-interface TupleT {
-    <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]>;
-}
-
-function _tuple(...decoders: $ReadOnlyArray<Decoder<mixed>>): Decoder<Array<mixed>> {
-    return ntuple(decoders.length).then((blobs, ok, err) => {
-        let allOk = true;
-
-        const rvs = decoders.map((decoder, i) => {
-            const blob = blobs[i];
-            const result = decoder.decode(blob);
-            if (result.ok) {
-                return result.value;
-            } else {
-                allOk = false;
-                return result.error;
-            }
-        });
-
-        if (allOk) {
-            return ok(rvs);
-        } else {
-            // If a decoder error has happened while unwrapping all the
-            // results, try to construct a good error message
-            return err(annotate(rvs));
-        }
-    });
-}
-
-/**
- * Accepts a tuple (an array with exactly _n_ items) of values accepted by the
- * _n_ given decoders.
- */
-export const tuple: TupleT = (_tuple: _Any);

package/lib/arrays.mjs

@@ -1,75 +0,0 @@
-import { annotate } from '../annotate.mjs'
-import { define } from '../Decoder.mjs'
-
-export var poja = define(function (blob, ok, err) {
-  if (!Array.isArray(blob)) {
-    return err('Must be an array')
-  }
-  return ok(blob.slice())
-})
-
-function all(items, blobs, ok, err) {
-  var results = []
-  for (var index = 0; index < items.length; ++index) {
-    var result = items[index]
-    if (result.ok) {
-      results.push(result.value)
-    } else {
-      var ann = result.error
-      var clone = [].concat(blobs)
-      clone.splice(index, 1, annotate(ann, ann.text ? ann.text + ' (at index ' + index + ')' : 'index ' + index))
-      return err(annotate(clone))
-    }
-  }
-  return ok(results)
-}
-
-export function array(decoder) {
-  return poja.then(function (blobs, ok, err) {
-    var results = blobs.map(decoder.decode)
-    return all(results, blobs, ok, err)
-  })
-}
-
-export function nonEmptyArray(decoder) {
-  return array(decoder).refine(function (arr) {
-    return arr.length > 0
-  }, 'Must be non-empty array')
-}
-
-export function set(decoder) {
-  return array(decoder).transform(function (items) {
-    return new Set(items)
-  })
-}
-var ntuple = function ntuple(n) {
-  return poja.refine(function (arr) {
-    return arr.length === n
-  }, 'Must be a ' + n + '-tuple')
-}
-
-function _tuple() {
-  for (var _len = arguments.length, decoders = new Array(_len), _key = 0; _key < _len; _key++) {
-    decoders[_key] = arguments[_key]
-  }
-  return ntuple(decoders.length).then(function (blobs, ok, err) {
-    var allOk = true
-    var rvs = decoders.map(function (decoder, i) {
-      var blob = blobs[i]
-      var result = decoder.decode(blob)
-      if (result.ok) {
-        return result.value
-      } else {
-        allOk = false
-        return result.error
-      }
-    })
-    if (allOk) {
-      return ok(rvs)
-    } else {
-      return err(annotate(rvs))
-    }
-  })
-}
-
-export var tuple = _tuple

package/lib/basics.d.ts

@@ -1,93 +0,0 @@
-import { Decoder, Scalar } from '../Decoder';
-
-/**
- * Accepts and returns only the literal `null` value.
- */
-export const null_: Decoder<null>;
-
-/**
- * Accepts and returns only the literal `undefined` value.
- */
-export const undefined_: Decoder<undefined>;
-
-/**
- * Accepts whatever the given decoder accepts, or `undefined`.
- *
- * If a default value is explicitly provided, return that instead in the
- * `undefined` case.
- */
-export function optional<T>(decoder: Decoder<T>): Decoder<T | undefined>;
-export function optional<T, V extends Scalar>(
-    decoder: Decoder<T>,
-    defaultValue: (() => V) | V,
-): Decoder<NonNullable<T> | V>;
-export function optional<T, V>(
-    decoder: Decoder<T>,
-    defaultValue: (() => V) | V,
-): Decoder<NonNullable<T> | V>;
-
-/**
- * Accepts whatever the given decoder accepts, or `null`.
- *
- * If a default value is explicitly provided, return that instead in the `null`
- * case.
- */
-export function nullable<T>(decoder: Decoder<T>): Decoder<T | null>;
-export function nullable<T, V extends Scalar>(
-    decoder: Decoder<T>,
-    defaultValue: (() => V) | V,
-): Decoder<NonNullable<T> | V>;
-export function nullable<T, V>(
-    decoder: Decoder<T>,
-    defaultValue: (() => V) | V,
-): Decoder<NonNullable<T> | V>;
-
-/**
- * Accepts whatever the given decoder accepts, or `null`, or `undefined`.
- *
- * If a default value is explicitly provided, return that instead in the
- * `null`/`undefined` case.
- */
-export function maybe<T>(decoder: Decoder<T>): Decoder<T | null | undefined>;
-export function maybe<T, V extends Scalar>(
-    decoder: Decoder<T>,
-    defaultValue: (() => V) | V,
-): Decoder<NonNullable<T> | V>;
-export function maybe<T, V>(
-    decoder: Decoder<T>,
-    defaultValue: (() => V) | V,
-): Decoder<NonNullable<T> | V>;
-
-/**
- * Accepts only the given constant value.
- */
-export function constant<T extends Scalar>(value: T): Decoder<T>;
-
-/**
- * Accepts anything, completely ignores it, and always returns the provided
- * value instead.
- *
- * This is useful to manually add extra fields to object decoders.
- */
-export function always<T extends Scalar>(value: T): Decoder<T>;
-export function always<T>(value: (() => T) | T): Decoder<T>;
-
-/**
- * Alias of always.
- */
-export function hardcoded<T extends Scalar>(value: T): Decoder<T>;
-export function hardcoded<T>(value: (() => T) | T): Decoder<T>;
-
-/**
- * Accepts anything and returns it unchanged.
- *
- * Useful for situation in which you don't know or expect a specific type. Of
- * course, the downside is that you won't know the type of the value statically
- * and you'll have to further refine it yourself.
- */
-export const unknown: Decoder<unknown>;
-
-/**
- * Alias of unknown.
- */
-export const mixed: Decoder<unknown>;

package/lib/basics.js

@@ -1,74 +0,0 @@
-'use strict'
-
-exports.__esModule = true
-exports.always = always
-exports.constant = constant
-exports.unknown = exports.undefined_ = exports.optional = exports.nullable = exports.null_ = exports.mixed = exports.maybe = exports.hardcoded = void 0
-var _Decoder = require('../Decoder')
-var _unions = require('./unions')
-
-var null_ = (0, _Decoder.define)(function (blob, ok, err) {
-  return blob === null ? ok(blob) : err('Must be null')
-})
-
-exports.null_ = null_
-var undefined_ = (0, _Decoder.define)(function (blob, ok, err) {
-  return blob === undefined ? ok(blob) : err('Must be undefined')
-})
-exports.undefined_ = undefined_
-var undefined_or_null = (0, _Decoder.define)(function (blob, ok, err) {
-  return blob === undefined || blob === null ? ok(blob) : err('Must be undefined or null')
-})
-function _maybeish(emptyCase) {
-  function _inner(decoder) {
-    var rv = (0, _unions.either)(emptyCase, decoder)
-    if (arguments.length >= 2) {
-      var _defaultValue = arguments[1]
-      var _defaultValue2 = typeof _defaultValue === 'function' ? _defaultValue() : _defaultValue
-      return rv.transform(function (value) {
-        return value != null ? value : _defaultValue2
-      })
-    } else {
-      return rv
-    }
-  }
-  return _inner
-}
-
-var nullable = _maybeish(null_)
-
-exports.nullable = nullable
-var optional = _maybeish(undefined_)
-
-exports.optional = optional
-var maybe = _maybeish(undefined_or_null)
-
-exports.maybe = maybe
-function constant(value) {
-  return (0, _Decoder.define)(function (blob, ok, err) {
-    return blob === value ? ok(value) : err('Must be constant ' + String(value))
-  })
-}
-
-function always(value) {
-  return (0, _Decoder.define)(
-    typeof value === 'function'
-      ? function (blob, ok, _) {
-          return ok(value())
-        }
-      : function (blob, ok, _) {
-          return ok(value)
-        }
-  )
-}
-
-var hardcoded = always
-
-exports.hardcoded = hardcoded
-var unknown = (0, _Decoder.define)(function (blob, ok, _) {
-  return ok(blob)
-})
-
-exports.unknown = unknown
-var mixed = unknown
-exports.mixed = mixed

package/lib/basics.js.flow

@@ -1,124 +0,0 @@
-// @flow strict
-
-import { define } from '../Decoder';
-import { either } from './unions';
-import type { _Any } from '../_utils';
-import type { Decoder, Scalar } from '../Decoder';
-
-/**
- * Accepts and returns only the literal `null` value.
- */
-export const null_: Decoder<null> = define((blob, ok, err) =>
-    blob === null ? ok(blob) : err('Must be null'),
-);
-
-/**
- * Accepts and returns only the literal `undefined` value.
- */
-export const undefined_: Decoder<void> = define((blob, ok, err) =>
-    blob === undefined ? ok(blob) : err('Must be undefined'),
-);
-
-const undefined_or_null: Decoder<null | void> = define((blob, ok, err) =>
-    blob === undefined || blob === null
-        ? ok(blob)
-        : // Combine error message into a single line for readability
-          err('Must be undefined or null'),
-);
-
-interface Maybeish<E> {
-    <T>(decoder: Decoder<T>): Decoder<E | T>;
-    <T, V>(
-        decoder: Decoder<T>,
-        defaultValue: (() => V) | V,
-    ): Decoder<$NonMaybeType<T> | V>;
-}
-
-function _maybeish<E>(emptyCase: Decoder<E>): Maybeish<E> {
-    function _inner(decoder /* defaultValue */) {
-        const rv = either(emptyCase, decoder);
-        if (
-            // If a default value is provided...
-            arguments.length >= 2
-        ) {
-            // ...then return the default value
-            const _defaultValue = arguments[1];
-            const defaultValue =
-                typeof _defaultValue === 'function' ? _defaultValue() : _defaultValue;
-            return rv.transform((value) => value ?? defaultValue);
-        } else {
-            // Otherwise the "normal" empty case
-            return rv;
-        }
-    }
-
-    return (_inner: _Any);
-}
-
-/**
- * Accepts whatever the given decoder accepts, or `null`.
- *
- * If a default value is explicitly provided, return that instead in the `null`
- * case.
- */
-export const nullable: Maybeish<null> = _maybeish(null_);
-
-/**
- * Accepts whatever the given decoder accepts, or `undefined`.
- *
- * If a default value is explicitly provided, return that instead in the
- * `undefined` case.
- */
-export const optional: Maybeish<void> = _maybeish(undefined_);
-
-/**
- * Accepts whatever the given decoder accepts, or `null`, or `undefined`.
- *
- * If a default value is explicitly provided, return that instead in the
- * `null`/`undefined` case.
- */
-export const maybe: Maybeish<null | void> = _maybeish(undefined_or_null);
-
-/**
- * Accepts only the given constant value.
- */
-export function constant<T: Scalar>(value: T): Decoder<T> {
-    return define((blob, ok, err) =>
-        blob === value ? ok(value) : err(`Must be constant ${String(value)}`),
-    );
-}
-
-/**
- * Accepts anything, completely ignores it, and always returns the provided
- * value instead.
- *
- * This is useful to manually add extra fields to object decoders.
- */
-export function always<T>(value: (() => T) | T): Decoder<T> {
-    return define(
-        typeof value === 'function'
-            ? (blob /* ignored */, ok, _) =>
-                  // $FlowFixMe[incompatible-use]
-                  ok(value())
-            : (blob /* ignored */, ok, _) => ok(value),
-    );
-}
-
-/**
- * Alias of always.
- */
-export const hardcoded: <T>(T) => Decoder<T> = always;
-
-/**
- * Accepts anything and returns it unchanged.
- *
- * Useful for situation in which you don't know or expect a specific type. Of
- * course, the downside is that you won't know the type of the value statically
- * and you'll have to further refine it yourself.
- */
-export const unknown: Decoder<mixed> = define((blob, ok, _) => ok(blob));
-
-/**
- * Alias of unknown.
- */
-export const mixed: Decoder<mixed> = unknown;

package/lib/basics.mjs

@@ -1,60 +0,0 @@
-import { define } from '../Decoder.mjs'
-import { either } from './unions.mjs'
-
-export var null_ = define(function (blob, ok, err) {
-  return blob === null ? ok(blob) : err('Must be null')
-})
-
-export var undefined_ = define(function (blob, ok, err) {
-  return blob === undefined ? ok(blob) : err('Must be undefined')
-})
-var undefined_or_null = define(function (blob, ok, err) {
-  return blob === undefined || blob === null ? ok(blob) : err('Must be undefined or null')
-})
-function _maybeish(emptyCase) {
-  function _inner(decoder) {
-    var rv = either(emptyCase, decoder)
-    if (arguments.length >= 2) {
-      var _defaultValue = arguments[1]
-      var _defaultValue2 = typeof _defaultValue === 'function' ? _defaultValue() : _defaultValue
-      return rv.transform(function (value) {
-        return value != null ? value : _defaultValue2
-      })
-    } else {
-      return rv
-    }
-  }
-  return _inner
-}
-
-export var nullable = _maybeish(null_)
-
-export var optional = _maybeish(undefined_)
-
-export var maybe = _maybeish(undefined_or_null)
-
-export function constant(value) {
-  return define(function (blob, ok, err) {
-    return blob === value ? ok(value) : err('Must be constant ' + String(value))
-  })
-}
-
-export function always(value) {
-  return define(
-    typeof value === 'function'
-      ? function (blob, ok, _) {
-          return ok(value())
-        }
-      : function (blob, ok, _) {
-          return ok(value)
-        }
-  )
-}
-
-export var hardcoded = always
-
-export var unknown = define(function (blob, ok, _) {
-  return ok(blob)
-})
-
-export var mixed = unknown

package/lib/booleans.d.ts

@@ -1,16 +0,0 @@
-import { Decoder } from '../Decoder';
-
-/**
- * Accepts and returns booleans.
- */
-export const boolean: Decoder<boolean>;
-
-/**
- * Accepts anything and will return its "truth" value. Will never reject.
- */
-export const truthy: Decoder<boolean>;
-
-/**
- * Accepts numbers, but return their boolean representation.
- */
-export const numericBoolean: Decoder<boolean>;

package/lib/booleans.js

@@ -1,21 +0,0 @@
-'use strict'
-
-exports.__esModule = true
-exports.truthy = exports.numericBoolean = exports['boolean'] = void 0
-var _Decoder = require('../Decoder')
-var _numbers = require('./numbers')
-
-var _boolean = (0, _Decoder.define)(function (blob, ok, err) {
-  return typeof blob === 'boolean' ? ok(blob) : err('Must be boolean')
-})
-
-exports['boolean'] = _boolean
-var truthy = (0, _Decoder.define)(function (blob, ok, _) {
-  return ok(!!blob)
-})
-
-exports.truthy = truthy
-var numericBoolean = _numbers.number.transform(function (n) {
-  return !!n
-})
-exports.numericBoolean = numericBoolean

package/lib/booleans.js.flow

@@ -1,22 +0,0 @@
-// @flow strict
-
-import { define } from '../Decoder';
-import { number } from './numbers';
-import type { Decoder } from '../Decoder';
-
-/**
- * Accepts and returns booleans.
- */
-export const boolean: Decoder<boolean> = define((blob, ok, err) => {
-    return typeof blob === 'boolean' ? ok(blob) : err('Must be boolean');
-});
-
-/**
- * Accepts anything and will return its "truth" value. Will never reject.
- */
-export const truthy: Decoder<boolean> = define((blob, ok, _) => ok(!!blob));
-
-/**
- * Accepts numbers, but return their boolean representation.
- */
-export const numericBoolean: Decoder<boolean> = number.transform((n) => !!n);

package/lib/booleans.mjs

@@ -1,15 +0,0 @@
-import { define } from '../Decoder.mjs'
-import { number } from './numbers.mjs'
-
-var _boolean = define(function (blob, ok, err) {
-  return typeof blob === 'boolean' ? ok(blob) : err('Must be boolean')
-})
-
-export { _boolean as boolean }
-export var truthy = define(function (blob, ok, _) {
-  return ok(!!blob)
-})
-
-export var numericBoolean = number.transform(function (n) {
-  return !!n
-})

package/lib/dates.d.ts

@@ -1,15 +0,0 @@
-import { Decoder } from '../Decoder';
-
-/**
- * Accepts and returns `Date` instances.
- */
-export const date: Decoder<Date>;
-
-/**
- * Accepts [ISO8601](https://en.wikipedia.org/wiki/ISO_8601)-formatted strings,
- * returns them as `Date` instances.
- *
- * This is very useful for working with dates in APIs: serialize them as
- * `.toISOString()` when sending, decode them with `iso8601` when receiving.
- */
-export const iso8601: Decoder<Date>;

package/lib/dates.js

@@ -1,23 +0,0 @@
-'use strict'
-
-exports.__esModule = true
-exports.iso8601 = exports.date = void 0
-var _utils = require('../_utils')
-var _Decoder = require('../Decoder')
-var _strings = require('./strings')
-var iso8601_re = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:[.]\d+)?(?:Z|[+-]\d{2}:?\d{2})$/
-
-var date = (0, _Decoder.define)(function (blob, ok, err) {
-  var date = (0, _utils.asDate)(blob)
-  return date !== null ? ok(date) : err('Must be a Date')
-})
-
-exports.date = date
-var iso8601 = (0, _strings.regex)(iso8601_re, 'Must be ISO8601 format').transform(function (value) {
-  var date = new Date(value)
-  if (isNaN(date.getTime())) {
-    throw new Error('Must be valid date/time value')
-  }
-  return date
-})
-exports.iso8601 = iso8601