decoders 2.0.0-beta8 → 2.0.1

package/core/array.js

@@ -1,104 +0,0 @@
-"use strict";
-
-exports.__esModule = true;
-exports.array = array;
-exports.nonEmptyArray = nonEmptyArray;
-exports.poja = void 0;
-
-var _annotate = require("../annotate");
-
-var _composition = require("./composition");
-
-var _result = require("../result");
-
-/**
- * Like a "Plain Old JavaScript Object", but for arrays: "Plain Old JavaScript
- * Array" ^_^
- */
-var poja = function poja(blob) {
-  if (!Array.isArray(blob)) {
-    return (0, _result.err)((0, _annotate.annotate)(blob, 'Must be an array'));
-  }
-
-  return (0, _result.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
- */
-
-
-exports.poja = poja;
-
-function all(items, blobs) {
-  var results = [];
-
-  for (var index = 0; index < items.length; ++index) {
-    var result = items[index];
-
-    if (result.type === 'ok') {
-      results.push(result.value);
-    } else {
-      var ann = result.error; // Rewrite the annotation to include the index information, and inject it into the original blob
-
-      var clone = [].concat(blobs);
-      clone.splice(index, 1, (0, _annotate.annotate)(ann, ann.text ? ann.text + " (at index " + index + ")" : "index " + index)); // const errValue = [];
-      // if (index > 0) {
-      //     errValue.push('...'); // TODO: make special mark, not string!
-      // }
-      // errValue.push(
-      // );
-      // if (index < iterable.length - 1) {
-      //     errValue.push('...'); // TODO: make special mark, not string!
-      // }
-
-      return (0, _result.err)((0, _annotate.annotate)(clone));
-    }
-  }
-
-  return (0, _result.ok)(results);
-}
-/**
- * Given a T, builds a decoder that assumes an array input and returns an
- * Array<T>.
- */
-
-
-function members(decoder) {
-  return function (blobs) {
-    var results = blobs.map(decoder);
-    var result = all(results, blobs);
-    return result;
-  };
-}
-/**
- * Builds a Decoder that returns Ok for values of `Array<T>`, given a Decoder
- * for `T`.  Err otherwise.
- */
-
-
-function array(decoder) {
-  return (0, _composition.compose)(poja, members(decoder));
-}
-/**
- * Builds a Decoder that returns Ok for values of `Array<T>`, but will reject
- * empty arrays.
- */
-
-
-function nonEmptyArray(decoder) {
-  return (0, _composition.predicate)(array(decoder), function (arr) {
-    return arr.length > 0;
-  }, 'Must be non-empty array');
-}

package/core/array.js.flow

@@ -1,100 +0,0 @@
-// @flow strict
-
-import { annotate } from '../annotate';
-import { compose, predicate } from './composition';
-import { err, ok } from '../result';
-import type { Decoder, DecodeResult } from '../_types';
-
-/**
- * Like a "Plain Old JavaScript Object", but for arrays: "Plain Old JavaScript
- * Array" ^_^
- */
-export const poja: Decoder<Array<mixed>> = (blob: mixed) => {
-    if (!Array.isArray(blob)) {
-        return err(annotate(blob, '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>,
-): DecodeResult<Array<T>> {
-    const results: Array<T> = [];
-    for (let index = 0; index < items.length; ++index) {
-        const result = items[index];
-        if (result.type === '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}`,
-                ),
-            );
-
-            // const errValue = [];
-            // if (index > 0) {
-            //     errValue.push('...'); // TODO: make special mark, not string!
-            // }
-            // errValue.push(
-            // );
-            // if (index < iterable.length - 1) {
-            //     errValue.push('...'); // TODO: make special mark, not string!
-            // }
-            return err(annotate(clone));
-        }
-    }
-    return ok(results);
-}
-
-/**
- * Given a T, builds a decoder that assumes an array input and returns an
- * Array<T>.
- */
-function members<T>(decoder: Decoder<T>): Decoder<Array<T>, Array<mixed>> {
-    return (blobs: $ReadOnlyArray<mixed>) => {
-        const results = blobs.map(decoder);
-        const result = all(results, blobs);
-        return result;
-    };
-}
-
-/**
- * Builds a Decoder that returns Ok for values of `Array<T>`, given a Decoder
- * for `T`.  Err otherwise.
- */
-export function array<T>(decoder: Decoder<T>): Decoder<Array<T>> {
-    return compose(poja, members(decoder));
-}
-
-/**
- * Builds a Decoder that returns Ok for values of `Array<T>`, but will reject
- * empty arrays.
- */
-export function nonEmptyArray<T>(decoder: Decoder<T>): Decoder<Array<T>> {
-    return predicate(array(decoder), (arr) => arr.length > 0, 'Must be non-empty array');
-}

package/core/array.mjs

@@ -1,91 +0,0 @@
-import { annotate } from '../annotate.mjs';
-import { compose, predicate } from './composition.mjs';
-import { err, ok } from '../result.mjs';
-
-/**
- * Like a "Plain Old JavaScript Object", but for arrays: "Plain Old JavaScript
- * Array" ^_^
- */
-export var poja = function poja(blob) {
-  if (!Array.isArray(blob)) {
-    return err(annotate(blob, '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(items, blobs) {
-  var results = [];
-
-  for (var index = 0; index < items.length; ++index) {
-    var result = items[index];
-
-    if (result.type === 'ok') {
-      results.push(result.value);
-    } else {
-      var ann = result.error; // Rewrite the annotation to include the index information, and inject it into the original blob
-
-      var clone = [].concat(blobs);
-      clone.splice(index, 1, annotate(ann, ann.text ? ann.text + " (at index " + index + ")" : "index " + index)); // const errValue = [];
-      // if (index > 0) {
-      //     errValue.push('...'); // TODO: make special mark, not string!
-      // }
-      // errValue.push(
-      // );
-      // if (index < iterable.length - 1) {
-      //     errValue.push('...'); // TODO: make special mark, not string!
-      // }
-
-      return err(annotate(clone));
-    }
-  }
-
-  return ok(results);
-}
-/**
- * Given a T, builds a decoder that assumes an array input and returns an
- * Array<T>.
- */
-
-
-function members(decoder) {
-  return function (blobs) {
-    var results = blobs.map(decoder);
-    var result = all(results, blobs);
-    return result;
-  };
-}
-/**
- * Builds a Decoder that returns Ok for values of `Array<T>`, given a Decoder
- * for `T`.  Err otherwise.
- */
-
-
-export function array(decoder) {
-  return compose(poja, members(decoder));
-}
-/**
- * Builds a Decoder that returns Ok for values of `Array<T>`, but will reject
- * empty arrays.
- */
-
-export function nonEmptyArray(decoder) {
-  return predicate(array(decoder), function (arr) {
-    return arr.length > 0;
-  }, 'Must be non-empty array');
-}

package/core/boolean.d.ts

@@ -1,5 +0,0 @@
-import { Decoder } from '../_types';
-
-export const boolean: Decoder<boolean>;
-export const truthy: Decoder<boolean>;
-export const numericBoolean: Decoder<boolean>;

package/core/boolean.js

@@ -1,40 +0,0 @@
-"use strict";
-
-exports.__esModule = true;
-exports.truthy = exports.numericBoolean = exports["boolean"] = void 0;
-
-var _annotate = require("../annotate");
-
-var _result = require("../result");
-
-var _composition = require("./composition");
-
-var _number = require("./number");
-
-/**
- * Decoder that only returns Ok for boolean inputs.  Err otherwise.
- */
-var _boolean = function _boolean(blob) {
-  return typeof blob === 'boolean' ? (0, _result.ok)(blob) : (0, _result.err)((0, _annotate.annotate)(blob, 'Must be boolean'));
-};
-/**
- * Decoder that returns true for all truthy values, and false otherwise.  Never fails.
- */
-
-
-exports["boolean"] = _boolean;
-
-var truthy = function truthy(blob) {
-  return (0, _result.ok)(!!blob);
-};
-/**
- * Decoder that only returns Ok for numeric input values representing booleans.
- * Returns their boolean representation.  Err otherwise.
- */
-
-
-exports.truthy = truthy;
-var numericBoolean = (0, _composition.map)(_number.number, function (n) {
-  return !!n;
-});
-exports.numericBoolean = numericBoolean;

package/core/boolean.js.flow

@@ -1,27 +0,0 @@
-// @flow strict
-
-import { annotate } from '../annotate';
-import { err, ok } from '../result';
-import { map } from './composition';
-import { number } from './number';
-import type { Decoder } from '../_types';
-
-/**
- * Decoder that only returns Ok for boolean inputs.  Err otherwise.
- */
-export const boolean: Decoder<boolean> = (blob: mixed) => {
-    return typeof blob === 'boolean' ? ok(blob) : err(annotate(blob, 'Must be boolean'));
-};
-
-/**
- * Decoder that returns true for all truthy values, and false otherwise.  Never fails.
- */
-export const truthy: Decoder<boolean> = (blob: mixed) => {
-    return ok(!!blob);
-};
-
-/**
- * Decoder that only returns Ok for numeric input values representing booleans.
- * Returns their boolean representation.  Err otherwise.
- */
-export const numericBoolean: Decoder<boolean> = map(number, (n) => !!n);

package/core/boolean.mjs

@@ -1,28 +0,0 @@
-import { annotate } from '../annotate.mjs';
-import { err, ok } from '../result.mjs';
-import { map } from './composition.mjs';
-import { number } from './number.mjs';
-
-/**
- * Decoder that only returns Ok for boolean inputs.  Err otherwise.
- */
-var _boolean = function _boolean(blob) {
-  return typeof blob === 'boolean' ? ok(blob) : err(annotate(blob, 'Must be boolean'));
-};
-/**
- * Decoder that returns true for all truthy values, and false otherwise.  Never fails.
- */
-
-
-export { _boolean as boolean };
-export var truthy = function truthy(blob) {
-  return ok(!!blob);
-};
-/**
- * Decoder that only returns Ok for numeric input values representing booleans.
- * Returns their boolean representation.  Err otherwise.
- */
-
-export var numericBoolean = map(number, function (n) {
-  return !!n;
-});

package/core/composition.d.ts

@@ -1,14 +0,0 @@
-import { Decoder } from '../_types';
-
-export function map<T, V>(decoder: Decoder<T>, mapper: (value: T) => V): Decoder<V>;
-export function compose<T, V>(decoder: Decoder<T>, next: Decoder<V, T>): Decoder<V>;
-export function predicate<T, N extends T>(
-    decoder: Decoder<T>,
-    predicate: (value: T) => value is N,
-    msg: string,
-): Decoder<N>;
-export function predicate<T>(
-    decoder: Decoder<T>,
-    predicate: (value: T) => boolean,
-    msg: string,
-): Decoder<T>;

package/core/composition.js

@@ -1,54 +0,0 @@
-"use strict";
-
-exports.__esModule = true;
-exports.compose = compose;
-exports.map = map;
-exports.predicate = predicate;
-
-var _result = require("../result");
-
-var _annotate = require("../annotate");
-
-/**
- * Given a decoder T and a mapping function from T's to V's, returns a decoder
- * for V's.  This is useful to change the original input data.
- */
-function map(decoder, mapper) {
-  return compose(decoder, function (x) {
-    try {
-      return (0, _result.ok)(mapper(x));
-    } catch (e) {
-      return (0, _result.err)((0, _annotate.annotate)(x, e instanceof Error ? e.message : String(e)));
-    }
-  });
-}
-/**
- * Compose two decoders by passing the result of the first into the second.
- * The second decoder may assume as its input type the output type of the first
- * decoder (so it's not necessary to accept the typical "mixed").  This is
- * useful for "narrowing down" the checks.  For example, if you want to write
- * a decoder for positive numbers, you can compose it from an existing decoder
- * for any number, and a decoder that, assuming a number, checks if it's
- * positive.  Very often combined with the predicate() helper as the second
- * argument.
- */
-
-
-function compose(decoder, next) {
-  return function (blob) {
-    return (0, _result.andThen)(decoder(blob), next);
-  };
-}
-/**
- * Factory function returning a Decoder<T>, given a predicate function that
- * accepts/rejects the input of type T.
- */
-
-
-function predicate(decoder, predicateFn, msg) {
-  return function (blob) {
-    return (0, _result.andThen)(decoder(blob), function (value) {
-      return predicateFn(value) ? (0, _result.ok)(value) : (0, _result.err)((0, _annotate.annotate)(value, msg));
-    });
-  };
-}

package/core/composition.js.flow

@@ -1,48 +0,0 @@
-// @flow strict
-
-import { andThen, err, ok } from '../result';
-import { annotate } from '../annotate';
-import type { Decoder } from '../_types';
-
-/**
- * Given a decoder T and a mapping function from T's to V's, returns a decoder
- * for V's.  This is useful to change the original input data.
- */
-export function map<T, V>(decoder: Decoder<T>, mapper: (T) => V): Decoder<V> {
-    return compose(decoder, (x) => {
-        try {
-            return ok(mapper(x));
-        } catch (e) {
-            return err(annotate(x, e instanceof Error ? e.message : String(e)));
-        }
-    });
-}
-
-/**
- * Compose two decoders by passing the result of the first into the second.
- * The second decoder may assume as its input type the output type of the first
- * decoder (so it's not necessary to accept the typical "mixed").  This is
- * useful for "narrowing down" the checks.  For example, if you want to write
- * a decoder for positive numbers, you can compose it from an existing decoder
- * for any number, and a decoder that, assuming a number, checks if it's
- * positive.  Very often combined with the predicate() helper as the second
- * argument.
- */
-export function compose<T, V>(decoder: Decoder<T>, next: Decoder<V, T>): Decoder<V> {
-    return (blob: mixed) => andThen(decoder(blob), next);
-}
-
-/**
- * Factory function returning a Decoder<T>, given a predicate function that
- * accepts/rejects the input of type T.
- */
-export function predicate<T>(
-    decoder: Decoder<T>,
-    predicateFn: (T) => boolean,
-    msg: string,
-): Decoder<T> {
-    return (blob: mixed) =>
-        andThen(decoder(blob), (value) =>
-            predicateFn(value) ? ok(value) : err(annotate(value, msg)),
-        );
-}

package/core/composition.mjs

@@ -1,44 +0,0 @@
-import { andThen, err, ok } from '../result.mjs';
-import { annotate } from '../annotate.mjs';
-
-/**
- * Given a decoder T and a mapping function from T's to V's, returns a decoder
- * for V's.  This is useful to change the original input data.
- */
-export function map(decoder, mapper) {
-  return compose(decoder, function (x) {
-    try {
-      return ok(mapper(x));
-    } catch (e) {
-      return err(annotate(x, e instanceof Error ? e.message : String(e)));
-    }
-  });
-}
-/**
- * Compose two decoders by passing the result of the first into the second.
- * The second decoder may assume as its input type the output type of the first
- * decoder (so it's not necessary to accept the typical "mixed").  This is
- * useful for "narrowing down" the checks.  For example, if you want to write
- * a decoder for positive numbers, you can compose it from an existing decoder
- * for any number, and a decoder that, assuming a number, checks if it's
- * positive.  Very often combined with the predicate() helper as the second
- * argument.
- */
-
-export function compose(decoder, next) {
-  return function (blob) {
-    return andThen(decoder(blob), next);
-  };
-}
-/**
- * Factory function returning a Decoder<T>, given a predicate function that
- * accepts/rejects the input of type T.
- */
-
-export function predicate(decoder, predicateFn, msg) {
-  return function (blob) {
-    return andThen(decoder(blob), function (value) {
-      return predicateFn(value) ? ok(value) : err(annotate(value, msg));
-    });
-  };
-}

package/core/constants.d.ts

@@ -1,11 +0,0 @@
-import { Decoder, Scalar } from '../_types';
-
-// Constants
-
-export const null_: Decoder<null>;
-export const undefined_: Decoder<undefined>;
-export function constant<T extends Scalar>(value: T): Decoder<T>;
-export function hardcoded<T extends Scalar>(value: T): Decoder<T>;
-export function hardcoded<T>(value: T): Decoder<T>;
-export const mixed: Decoder<unknown>;
-export const unknown: Decoder<unknown>;

package/core/constants.js

@@ -1,65 +0,0 @@
-"use strict";
-
-exports.__esModule = true;
-exports.constant = constant;
-exports.hardcoded = hardcoded;
-exports.unknown = exports.undefined_ = exports.null_ = exports.mixed = void 0;
-
-var _annotate = require("../annotate");
-
-var _result = require("../result");
-
-/**
- * Decoder that only returns Ok for `null` inputs.  Err otherwise.
- */
-var null_ = function null_(blob) {
-  return blob === null ? (0, _result.ok)(blob) : (0, _result.err)((0, _annotate.annotate)(blob, 'Must be null'));
-};
-/**
- * Decoder that only returns Ok for `undefined` inputs.  Err otherwise.
- */
-
-
-exports.null_ = null_;
-
-var undefined_ = function undefined_(blob) {
-  return blob === undefined ? (0, _result.ok)(blob) : (0, _result.err)((0, _annotate.annotate)(blob, 'Must be undefined'));
-};
-/**
- * Decoder that only returns Ok for the given value constant.  Err otherwise.
- */
-
-
-exports.undefined_ = undefined_;
-
-function constant(value) {
-  return function (blob) {
-    return blob === value ? (0, _result.ok)(value) : (0, _result.err)((0, _annotate.annotate)(blob, "Must be constant " + String(value)));
-  };
-}
-/**
- * Decoder that always returns Ok for the given hardcoded value, no matter what the input.
- */
-
-
-function hardcoded(value) {
-  return function () {
-    return (0, _result.ok)(value);
-  };
-}
-/**
- * Decoder that always returns Ok for the given hardcoded value, no matter what the input.
- */
-
-
-var unknown = function unknown(blob) {
-  return (0, _result.ok)(blob);
-};
-/**
- * Alias of unknown.
- */
-
-
-exports.unknown = unknown;
-var mixed = unknown;
-exports.mixed = mixed;

package/core/constants.js.flow

@@ -1,44 +0,0 @@
-// @flow strict
-
-import { annotate } from '../annotate';
-import { err, ok } from '../result';
-import type { Decoder, Scalar } from '../_types';
-
-/**
- * Decoder that only returns Ok for `null` inputs.  Err otherwise.
- */
-export const null_: Decoder<null> = (blob: mixed) =>
-    blob === null ? ok(blob) : err(annotate(blob, 'Must be null'));
-
-/**
- * Decoder that only returns Ok for `undefined` inputs.  Err otherwise.
- */
-export const undefined_: Decoder<void> = (blob: mixed) =>
-    blob === undefined ? ok(blob) : err(annotate(blob, 'Must be undefined'));
-
-/**
- * Decoder that only returns Ok for the given value constant.  Err otherwise.
- */
-export function constant<T: Scalar>(value: T): Decoder<T> {
-    return (blob: mixed) =>
-        blob === value
-            ? ok(value)
-            : err(annotate(blob, `Must be constant ${String(value)}`));
-}
-
-/**
- * Decoder that always returns Ok for the given hardcoded value, no matter what the input.
- */
-export function hardcoded<T>(value: T): Decoder<T> {
-    return () => ok(value);
-}
-
-/**
- * Decoder that always returns Ok for the given hardcoded value, no matter what the input.
- */
-export const unknown: Decoder<mixed> = (blob: mixed) => ok(blob);
-
-/**
- * Alias of unknown.
- */
-export const mixed: Decoder<mixed> = unknown;