decoders 2.0.0-beta1 → 2.0.0-beta10

package/lib/booleans.js

@@ -0,0 +1,35 @@
+"use strict";
+
+exports.__esModule = true;
+exports.truthy = exports.numericBoolean = exports["boolean"] = void 0;
+
+var _Decoder = require("../Decoder");
+
+var _numbers = require("./numbers");
+
+/**
+ * Accepts and returns booleans.
+ */
+var _boolean = (0, _Decoder.define)(function (blob, ok, err) {
+  return typeof blob === 'boolean' ? ok(blob) : err('Must be boolean');
+});
+/**
+ * Accepts anything and will return its “truth” value. Will never reject.
+ */
+
+
+exports["boolean"] = _boolean;
+var truthy = (0, _Decoder.define)(function (blob, ok, _) {
+  return ok(!!blob);
+});
+/**
+ * Accepts numbers, but return their boolean representation.
+ */
+
+exports.truthy = truthy;
+
+var numericBoolean = _numbers.number.transform(function (n) {
+  return !!n;
+});
+
+exports.numericBoolean = numericBoolean;

package/lib/booleans.js.flow

@@ -0,0 +1,22 @@
+// @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

@@ -0,0 +1,25 @@
+import { define } from '../Decoder.mjs';
+import { number } from './numbers.mjs';
+
+/**
+ * Accepts and returns booleans.
+ */
+var _boolean = define(function (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 { _boolean as boolean };
+export var truthy = define(function (blob, ok, _) {
+  return ok(!!blob);
+});
+/**
+ * Accepts numbers, but return their boolean representation.
+ */
+
+export var numericBoolean = number.transform(function (n) {
+  return !!n;
+});

package/{ts/date.d.ts → lib/dates.d.ts}

@@ -1,4 +1,4 @@
-import { Decoder } from '../_types';
+import { Decoder } from '../Decoder';
 
 export const date: Decoder<Date>;
 export const iso8601: Decoder<Date>;

package/lib/dates.js

@@ -0,0 +1,44 @@
+"use strict";
+
+exports.__esModule = true;
+exports.iso8601 = exports.date = void 0;
+
+var _utils = require("../_utils");
+
+var _Decoder = require("../Decoder");
+
+var _strings = require("./strings");
+
+// 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
+var 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.
+ */
+
+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');
+});
+/**
+ * Accepts [ISO8601](https://en.wikipedia.org/wiki/ISO_8601)-formatted strings,
+ * returns then 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.
+ */
+
+exports.date = date;
+var iso8601 = // Input itself needs to match the ISO8601 regex...
+(0, _strings.regex)(iso8601_re, 'Must be ISO8601 format').transform( // Make sure it is a _valid_ date
+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

@@ -0,0 +1,40 @@
+// @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 then 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

@@ -0,0 +1,34 @@
+import { asDate } from '../_utils.mjs';
+import { define } from '../Decoder.mjs';
+import { regex } from './strings.mjs';
+// 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
+var 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 var date = define(function (blob, ok, err) {
+  var 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 then 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 var iso8601 = // Input itself needs to match the ISO8601 regex...
+regex(iso8601_re, 'Must be ISO8601 format').transform( // Make sure it is a _valid_ date
+function (value) {
+  var date = new Date(value);
+
+  if (isNaN(date.getTime())) {
+    throw new Error('Must be valid date/time value');
+  }
+
+  return date;
+});

package/{ts → lib}/json.d.ts

@@ -1,4 +1,4 @@
-import { Decoder } from '../_types';
+import { Decoder } from '../Decoder';
 
 export type JSONValue = null | string | number | boolean | JSONObject | JSONArray;
 export interface JSONObject {

package/lib/json.js

@@ -0,0 +1,55 @@
+"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");
+
+/**
+ * Like `json`, but will only decode when the JSON value is an object.
+ */
+var jsonObject = (0, _utilities.lazy)(function () {
+  return (0, _objects.dict)(json);
+});
+/**
+ * Like `json`, but will only decode when the JSON value is an array.
+ */
+
+exports.jsonObject = jsonObject;
+var jsonArray = (0, _utilities.lazy)(function () {
+  return (0, _arrays.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[]
+ * ```
+ */
+
+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

@@ -0,0 +1,50 @@
+// @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>;
+
+/**
+ * Like `json`, but will only decode when the JSON value is an object.
+ */
+export const jsonObject: Decoder<JSONObject> = lazy(() => dict(json));
+
+/**
+ * Like `json`, but will only decode when the JSON value is an array.
+ */
+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

@@ -0,0 +1,40 @@
+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';
+
+/**
+ * Like `json`, but will only decode when the JSON value is an object.
+ */
+export var jsonObject = lazy(function () {
+  return dict(json);
+});
+/**
+ * Like `json`, but will only decode when the JSON value is an array.
+ */
+
+export var jsonArray = lazy(function () {
+  return 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 var json = either(null_, string, number, _boolean, jsonObject, jsonArray).describe('Must be valid JSON value');

package/{ts/number.d.ts → lib/numbers.d.ts}

@@ -1,5 +1,6 @@
-import { Decoder } from '../_types';
+import { Decoder } from '../Decoder';
 
+export const anyNumber: Decoder<number>;
 export const integer: Decoder<number>;
 export const number: Decoder<number>;
 export const positiveInteger: Decoder<number>;

package/lib/numbers.js

@@ -0,0 +1,52 @@
+"use strict";
+
+exports.__esModule = true;
+exports.positiveNumber = exports.positiveInteger = exports.number = exports.integer = exports.anyNumber = void 0;
+
+var _Decoder = require("../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.
+ */
+var anyNumber = (0, _Decoder.define)(function (blob, ok, err) {
+  return 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.
+ */
+
+exports.anyNumber = anyNumber;
+var number = anyNumber.refine(function (n) {
+  return Number.isFinite(n);
+}, 'Number must be finite');
+/**
+ * Accepts only finite whole numbers.
+ */
+
+exports.number = number;
+var integer = number.refine(function (n) {
+  return Number.isInteger(n);
+}, 'Number must be an integer');
+/**
+ * Accepts only positive finite numbers.
+ */
+
+exports.integer = integer;
+var positiveNumber = number.refine(function (n) {
+  return n >= 0;
+}, 'Number must be positive');
+/**
+ * Accepts only positive finite whole numbers.
+ */
+
+exports.positiveNumber = positiveNumber;
+var positiveInteger = integer.refine(function (n) {
+  return n >= 0;
+}, 'Number must be positive');
+exports.positiveInteger = positiveInteger;

package/lib/numbers.js.flow

@@ -0,0 +1,49 @@
+// @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 positive finite numbers.
+ */
+export const positiveNumber: Decoder<number> = number.refine(
+    (n) => n >= 0,
+    'Number must be positive',
+);
+
+/**
+ * Accepts only positive finite whole numbers.
+ */
+export const positiveInteger: Decoder<number> = integer.refine(
+    (n) => n >= 0,
+    'Number must be positive',
+);

package/lib/numbers.mjs

@@ -0,0 +1,42 @@
+import { define } from '../Decoder.mjs';
+
+/**
+ * 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 var anyNumber = define(function (blob, ok, err) {
+  return 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 var number = anyNumber.refine(function (n) {
+  return Number.isFinite(n);
+}, 'Number must be finite');
+/**
+ * Accepts only finite whole numbers.
+ */
+
+export var integer = number.refine(function (n) {
+  return Number.isInteger(n);
+}, 'Number must be an integer');
+/**
+ * Accepts only positive finite numbers.
+ */
+
+export var positiveNumber = number.refine(function (n) {
+  return n >= 0;
+}, 'Number must be positive');
+/**
+ * Accepts only positive finite whole numbers.
+ */
+
+export var positiveInteger = integer.refine(function (n) {
+  return n >= 0;
+}, 'Number must be positive');

package/{ts/object.d.ts → lib/objects.d.ts}

@@ -1,4 +1,6 @@
-import { Decoder, DecoderType } from '../_types';
+/// <reference lib="es6" />
+
+import { Decoder, DecoderType } from '../Decoder';
 import { AllowImplicit } from './_helpers';
 
 export type ObjectDecoderType<T> = AllowImplicit<{
@@ -8,7 +10,7 @@ export type ObjectDecoderType<T> = AllowImplicit<{
 export const pojo: Decoder<{ [key: string]: unknown }>;
 
 export function object<O extends { [key: string]: Decoder<any> }>(
-    mapping: O,
+    decodersByKey: O,
 ): Decoder<{ [K in keyof ObjectDecoderType<O>]: ObjectDecoderType<O>[K] }>;
 //         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 //         This is basically just equivalent to:
@@ -19,15 +21,18 @@ export function object<O extends { [key: string]: Decoder<any> }>(
 //         work with while developing.
 
 export function exact<O extends { [key: string]: Decoder<any> }>(
-    mapping: O,
+    decodersByKey: O,
 ): Decoder<{ [K in keyof ObjectDecoderType<O>]: ObjectDecoderType<O>[K] }>;
 //         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 //         Ditto (see above)
 
 export function inexact<O extends { [key: string]: Decoder<any> }>(
-    mapping: O,
+    decodersByKey: O,
 ): Decoder<
     { [K in keyof ObjectDecoderType<O>]: ObjectDecoderType<O>[K] } & {
         [extra: string]: unknown;
     }
 >;
+
+export function mapping<T>(decoder: Decoder<T>): Decoder<Map<string, T>>;
+export function dict<T>(decoder: Decoder<T>): Decoder<{ [key: string]: T }>;