decoders 2.0.5 → 2.2.0-test

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

package/lib/dates.js.flow

@@ -1,40 +0,0 @@
-// @flow strict
-
-import { asDate } from '../_utils';
-import { define } from '../Decoder';
-import { regex } from './strings';
-import type { Decoder } from '../Decoder';
-
-// Only matches the shape.  This "over-matches" some values that still aren't
-// valid dates (like 9999-99-99), but those will be caught by JS Date's
-// internal validations
-const iso8601_re =
-    /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:[.]\d+)?(?:Z|[+-]\d{2}:?\d{2})$/;
-
-/**
- * Accepts and returns `Date` instances.
- */
-export const date: Decoder<Date> = define((blob, ok, err) => {
-    const date = asDate(blob);
-    return date !== null ? ok(date) : err('Must be a 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> =
-    // Input itself needs to match the ISO8601 regex...
-    regex(iso8601_re, 'Must be ISO8601 format').transform(
-        // Make sure it is a _valid_ date
-        (value: string) => {
-            const date = new Date(value);
-            if (isNaN(date.getTime())) {
-                throw new Error('Must be valid date/time value');
-            }
-            return date;
-        },
-    );

package/lib/dates.mjs

@@ -1,17 +0,0 @@
-import { asDate } from '../_utils.mjs'
-import { define } from '../Decoder.mjs'
-import { regex } from './strings.mjs'
-var iso8601_re = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:[.]\d+)?(?:Z|[+-]\d{2}:?\d{2})$/
-
-export var date = define(function (blob, ok, err) {
-  var date = asDate(blob)
-  return date !== null ? ok(date) : err('Must be a Date')
-})
-
-export var iso8601 = 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
-})

package/lib/json.d.ts

@@ -1,35 +0,0 @@
-import { Decoder } from '../Decoder';
-
-export type JSONValue = null | string | number | boolean | JSONObject | JSONArray;
-export interface JSONObject {
-    [key: string]: JSONValue | undefined;
-}
-export type JSONArray = JSONValue[];
-
-/**
- * Accepts any value that's a valid JSON value.
- *
- * In other words: any value returned by `JSON.parse()` should decode without
- * failure.
- *
- * ```typescript
- * type JSONValue =
- *     | null
- *     | string
- *     | number
- *     | boolean
- *     | { [string]: JSONValue }
- *     | JSONValue[]
- * ```
- */
-export const json: Decoder<JSONValue>;
-
-/**
- * Accepts arrays that contain only valid JSON values.
- */
-export const jsonArray: Decoder<JSONArray>;
-
-/**
- * Accepts objects that contain only valid JSON values.
- */
-export const jsonObject: Decoder<JSONObject>;

package/lib/json.js

@@ -1,25 +0,0 @@
-'use strict'
-
-exports.__esModule = true
-exports.jsonObject = exports.jsonArray = exports.json = void 0
-var _arrays = require('./arrays')
-var _booleans = require('./booleans')
-var _objects = require('./objects')
-var _unions = require('./unions')
-var _utilities = require('./utilities')
-var _basics = require('./basics')
-var _numbers = require('./numbers')
-var _strings = require('./strings')
-
-var jsonObject = (0, _utilities.lazy)(function () {
-  return (0, _objects.dict)(json)
-})
-
-exports.jsonObject = jsonObject
-var jsonArray = (0, _utilities.lazy)(function () {
-  return (0, _arrays.array)(json)
-})
-
-exports.jsonArray = jsonArray
-var json = (0, _unions.either)(_basics.null_, _strings.string, _numbers.number, _booleans['boolean'], jsonObject, jsonArray).describe('Must be valid JSON value')
-exports.json = json

package/lib/json.js.flow

@@ -1,50 +0,0 @@
-// @flow strict
-
-import { array } from './arrays';
-import { boolean } from './booleans';
-import { dict } from './objects';
-import { either } from './unions';
-import { lazy } from './utilities';
-import { null_ } from './basics';
-import { number } from './numbers';
-import { string } from './strings';
-import type { Decoder } from '../Decoder';
-
-export type JSONValue = null | string | number | boolean | JSONObject | JSONArray;
-export type JSONObject = { [string]: JSONValue };
-export type JSONArray = Array<JSONValue>;
-
-/**
- * Accepts objects that contain only valid JSON values.
- */
-export const jsonObject: Decoder<JSONObject> = lazy(() => dict(json));
-
-/**
- * Accepts arrays that contain only valid JSON values.
- */
-export const jsonArray: Decoder<JSONArray> = lazy(() => array(json));
-
-/**
- * Accepts any value that's a valid JSON value.
- *
- * In other words: any value returned by `JSON.parse()` should decode without
- * failure.
- *
- * ```typescript
- * type JSONValue =
- *     | null
- *     | string
- *     | number
- *     | boolean
- *     | { [string]: JSONValue }
- *     | JSONValue[]
- * ```
- */
-export const json: Decoder<JSONValue> = either(
-    null_,
-    string,
-    number,
-    boolean,
-    jsonObject,
-    jsonArray,
-).describe('Must be valid JSON value');

package/lib/json.mjs

@@ -1,18 +0,0 @@
-import { array } from './arrays.mjs'
-import { boolean as _boolean } from './booleans.mjs'
-import { dict } from './objects.mjs'
-import { either } from './unions.mjs'
-import { lazy } from './utilities.mjs'
-import { null_ } from './basics.mjs'
-import { number } from './numbers.mjs'
-import { string } from './strings.mjs'
-
-export var jsonObject = lazy(function () {
-  return dict(json)
-})
-
-export var jsonArray = lazy(function () {
-  return array(json)
-})
-
-export var json = either(null_, string, number, _boolean, jsonObject, jsonArray).describe('Must be valid JSON value')

package/lib/numbers.d.ts

@@ -1,31 +0,0 @@
-import { Decoder } from '../Decoder';
-
-/**
- * Accepts any valid ``number`` value.
- *
- * This also accepts special values like `NaN` and `Infinity`. Unless you
- * want to deliberately accept those, you'll likely want to use the
- * `number` decoder instead.
- */
-export const anyNumber: Decoder<number>;
-
-/**
- * Accepts finite numbers (can be integer or float values). Values `NaN`,
- * or positive and negative `Infinity` will get rejected.
- */
-export const number: Decoder<number>;
-
-/**
- * Accepts only finite whole numbers.
- */
-export const integer: Decoder<number>;
-
-/**
- * Accepts only non-negative (zero or positive) finite numbers.
- */
-export const positiveNumber: Decoder<number>;
-
-/**
- * Accepts only non-negative (zero or positive) finite whole numbers.
- */
-export const positiveInteger: Decoder<number>;

package/lib/numbers.js

@@ -1,34 +0,0 @@
-'use strict'
-
-exports.__esModule = true
-exports.positiveNumber = exports.positiveInteger = exports.number = exports.integer = exports.anyNumber = void 0
-var _Decoder = require('../Decoder')
-
-var anyNumber = (0, _Decoder.define)(function (blob, ok, err) {
-  return typeof blob === 'number' ? ok(blob) : err('Must be number')
-})
-
-exports.anyNumber = anyNumber
-var number = anyNumber.refine(function (n) {
-  return Number.isFinite(n)
-}, 'Number must be finite')
-
-exports.number = number
-var integer = number.refine(function (n) {
-  return Number.isInteger(n)
-}, 'Number must be an integer')
-
-exports.integer = integer
-var positiveNumber = number
-  .refine(function (n) {
-    return n >= 0
-  }, 'Number must be positive')
-  .transform(Math.abs)
-
-exports.positiveNumber = positiveNumber
-var positiveInteger = integer
-  .refine(function (n) {
-    return n >= 0
-  }, 'Number must be positive')
-  .transform(Math.abs)
-exports.positiveInteger = positiveInteger

package/lib/numbers.js.flow

@@ -1,46 +0,0 @@
-// @flow strict
-
-import { define } from '../Decoder';
-import type { Decoder } from '../Decoder';
-
-/**
- * Accepts any valid ``number`` value.
- *
- * This also accepts special values like `NaN` and `Infinity`. Unless you
- * want to deliberately accept those, you'll likely want to use the
- * `number` decoder instead.
- */
-export const anyNumber: Decoder<number> = define((blob, ok, err) =>
-    typeof blob === 'number' ? ok(blob) : err('Must be number'),
-);
-
-/**
- * Accepts finite numbers (can be integer or float values). Values `NaN`,
- * or positive and negative `Infinity` will get rejected.
- */
-export const number: Decoder<number> = anyNumber.refine(
-    (n) => Number.isFinite(n),
-    'Number must be finite',
-);
-
-/**
- * Accepts only finite whole numbers.
- */
-export const integer: Decoder<number> = number.refine(
-    (n) => Number.isInteger(n),
-    'Number must be an integer',
-);
-
-/**
- * Accepts only non-negative (zero or positive) finite numbers.
- */
-export const positiveNumber: Decoder<number> = number
-    .refine((n) => n >= 0, 'Number must be positive')
-    .transform(Math.abs); // Just here to handle the -0 case
-
-/**
- * Accepts only non-negative (zero or positive) finite whole numbers.
- */
-export const positiveInteger: Decoder<number> = integer
-    .refine((n) => n >= 0, 'Number must be positive')
-    .transform(Math.abs); // Just here to handle the -0 case

package/lib/numbers.mjs

@@ -1,25 +0,0 @@
-import { define } from '../Decoder.mjs'
-
-export var anyNumber = define(function (blob, ok, err) {
-  return typeof blob === 'number' ? ok(blob) : err('Must be number')
-})
-
-export var number = anyNumber.refine(function (n) {
-  return Number.isFinite(n)
-}, 'Number must be finite')
-
-export var integer = number.refine(function (n) {
-  return Number.isInteger(n)
-}, 'Number must be an integer')
-
-export var positiveNumber = number
-  .refine(function (n) {
-    return n >= 0
-  }, 'Number must be positive')
-  .transform(Math.abs)
-
-export var positiveInteger = integer
-  .refine(function (n) {
-    return n >= 0
-  }, 'Number must be positive')
-  .transform(Math.abs)