decoders 2.1.0 → 2.2.0-test2

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)

package/lib/objects.d.ts

@@ -1,76 +0,0 @@
-/// <reference lib="es6" />
-
-import { Decoder, DecoderType } from '../Decoder';
-import { AllowImplicit } from './_helpers';
-
-export type ObjectDecoderType<T> = AllowImplicit<{
-    [key in keyof T]: DecoderType<T[key]>;
-}>;
-
-/**
- * Accepts any "plain old JavaScript object", but doesn't validate its keys or
- * values further.
- */
-export const pojo: Decoder<Record<string, unknown>>;
-
-/**
- * Accepts objects with fields matching the given decoders. Extra fields that
- * exist on the input object are ignored and will not be returned.
- */
-export function object(decodersByKey: Record<any, never>): Decoder<Record<string, never>>;
-export function object<O extends Record<string, Decoder<any>>>(
-    decodersByKey: 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.
-
-/**
- * Like `object()`, but will reject inputs that contain extra fields that are
- * not specified explicitly.
- */
-export function exact(decodersByKey: Record<any, never>): Decoder<Record<string, never>>;
-export function exact<O extends Record<string, Decoder<any>>>(
-    decodersByKey: O,
-): Decoder<{ [K in keyof ObjectDecoderType<O>]: ObjectDecoderType<O>[K] }>;
-//         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-//         Ditto (see above)
-
-/**
- * Like `object()`, but will pass through any extra fields on the input object
- * unvalidated that will thus be of `unknown` type statically.
- */
-export function inexact(
-    decodersByKey: Record<any, never>,
-): Decoder<Record<string, unknown>>;
-export function inexact<O extends Record<string, Decoder<any>>>(
-    decodersByKey: O,
-): Decoder<
-    { [K in keyof ObjectDecoderType<O>]: ObjectDecoderType<O>[K] } & Record<
-        string,
-        unknown
-    >
->;
-
-/**
- * Accepts objects where all values match the given decoder, and returns the
- * result as a `Record<string, T>`.
- *
- * The main difference between `object()` and `dict()` is that you'd typically
- * use `object()` if this is a record-like object, where all field names are
- * known and the values are heterogeneous. Whereas with `dict()` the keys are
- * typically dynamic and the values homogeneous, like in a dictionary,
- * a lookup table, or a cache.
- */
-export function dict<T>(decoder: Decoder<T>): Decoder<Record<string, T>>;
-
-/**
- * Similar to `dict()`, but returns the result as a `Map<string, T>` (an [ES6
- * Map](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map))
- * instead.
- */
-export function mapping<T>(decoder: Decoder<T>): Decoder<Map<string, T>>;

package/lib/objects.js

@@ -1,138 +0,0 @@
-'use strict'
-
-exports.__esModule = true
-exports.dict = dict
-exports.exact = exact
-exports.inexact = inexact
-exports.mapping = mapping
-exports.object = object
-exports.pojo = void 0
-var _annotate = require('../annotate')
-var _Decoder = require('../Decoder')
-var _utils = require('../_utils')
-
-var pojo = (0, _Decoder.define)(function (blob, ok, err) {
-  return blob !== null && blob !== undefined && typeof blob === 'object' && Object.prototype.toString.call(blob) === '[object Object]' ? ok(blob) : err('Must be an object')
-})
-
-exports.pojo = pojo
-function object(decodersByKey) {
-  var knownKeys = new Set(Object.keys(decodersByKey))
-  return pojo.then(function (plainObj, ok, err) {
-    var actualKeys = new Set(Object.keys(plainObj))
-    var missingKeys = (0, _utils.subtract)(knownKeys, actualKeys)
-    var record = {}
-    var errors = null
-    Object.keys(decodersByKey).forEach(function (key) {
-      var decoder = decodersByKey[key]
-      var rawValue = plainObj[key]
-      var result = decoder.decode(rawValue)
-      if (result.ok) {
-        var value = result.value
-        if (value !== undefined) {
-          record[key] = value
-        }
-        missingKeys['delete'](key)
-      } else {
-        var ann = result.error
-        if (rawValue === undefined) {
-          missingKeys.add(key)
-        } else {
-          if (errors === null) {
-            errors = {}
-          }
-          errors[key] = ann
-        }
-      }
-    })
-    if (errors || missingKeys.size > 0) {
-      var objAnn = (0, _annotate.annotateObject)(plainObj)
-      if (errors) {
-        objAnn = (0, _annotate.merge)(objAnn, errors)
-      }
-      if (missingKeys.size > 0) {
-        var errMsg = Array.from(missingKeys)
-          .map(function (key) {
-            return '"' + key + '"'
-          })
-          .join(', ')
-        var pluralized = missingKeys.size > 1 ? 'keys' : 'key'
-        objAnn = (0, _annotate.updateText)(objAnn, 'Missing ' + pluralized + ': ' + errMsg)
-      }
-      return err(objAnn)
-    }
-    return ok(record)
-  })
-}
-
-function exact(decodersByKey) {
-  var allowedKeys = new Set(Object.keys(decodersByKey))
-  var checked = pojo.reject(function (plainObj) {
-    var actualKeys = new Set(Object.keys(plainObj))
-    var extraKeys = (0, _utils.subtract)(actualKeys, allowedKeys)
-    return extraKeys.size > 0 ? 'Unexpected extra keys: ' + Array.from(extraKeys).join(', ') : null
-  })
-  return checked.then(object(decodersByKey).decode)
-}
-
-function inexact(decodersByKey) {
-  return pojo.then(function (plainObj) {
-    var allkeys = new Set(Object.keys(plainObj))
-    var decoder = object(decodersByKey).transform(function (safepart) {
-      var safekeys = new Set(Object.keys(decodersByKey))
-      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] = plainObj[k]
-        }
-      })
-      return rv
-    })
-    return decoder.decode(plainObj)
-  })
-}
-
-function dict(decoder) {
-  return pojo.then(function (plainObj, ok, err) {
-    var rv = {}
-    var errors = null
-    Object.keys(plainObj).forEach(function (key) {
-      var value = plainObj[key]
-      var result = decoder.decode(value)
-      if (result.ok) {
-        if (errors === null) {
-          rv[key] = result.value
-        }
-      } else {
-        rv = {}
-        if (errors === null) {
-          errors = {}
-        }
-        errors[key] = result.error
-      }
-    })
-    if (errors !== null) {
-      return err((0, _annotate.merge)((0, _annotate.annotateObject)(plainObj), errors))
-    } else {
-      return ok(rv)
-    }
-  })
-}
-
-function mapping(decoder) {
-  return dict(decoder).transform(function (obj) {
-    return new Map(
-      Object.keys(obj).map(function (key) {
-        return [key, obj[key]]
-      })
-    )
-  })
-}