decoders 2.0.0-beta9 → 2.0.0

package/result.mjs

@@ -24,58 +24,4 @@ export function err(error) {
     value: undefined,
     error: error
   };
-}
-/**
- * Unwrap the value from this Result instance if this is an "Ok" result.
- * Otherwise, will throw the "Err" error via a runtime exception.
- */
-
-export function unwrap(result) {
-  if (result.ok) {
-    return result.value;
-  } else {
-    throw result.error;
-  }
-}
-export function expect(result, message) {
-  if (result.ok) {
-    return result.value;
-  } else {
-    throw message instanceof Error ? message : new Error(message);
-  }
-}
-export function dispatch(result, okCallback, errCallback) {
-  return result.ok ? okCallback(result.value) : errCallback(result.error);
-}
-/**
- * Like .and(), aka &&, but the second argument gets evaluated lazily only if
- * the first result is an Ok result. If so, it has access to the Ok value from
- * the first argument.
- */
-
-export function andThen(result1, lazyResult2) {
-  return result1.ok ? lazyResult2(result1.value) : result1;
-}
-/**
- * Like .or(), aka ||, but the second argument gets evaluated lazily only if
- * the first result is an Err result. If so, it has access to the Err value
- * from the first argument.
- */
-
-export function orElse(result1, lazyResult2) {
-  return result1.ok ? result1 : lazyResult2(result1.error);
-}
-/**
- * Transform an Ok result. Will not touch Err results.
- */
-
-export function mapOk(result, mapper) {
-  return result.ok ? ok(mapper(result.value)) : result;
-}
-/**
- * Transform an Err value. Will not touch Ok results.
- */
-
-export function mapError(result, mapper) {
-  return result.ok ? result : err(mapper(result.error));
 }

package/_guard.d.ts

@@ -1,7 +0,0 @@
-import { Annotation } from './annotate';
-import { Decoder, Guard } from './_types';
-
-export function guard<T>(
-    decoder: Decoder<T>,
-    formatter?: (annotation: Annotation) => string,
-): Guard<T>;

package/_guard.js

@@ -1,22 +0,0 @@
-"use strict";
-
-exports.__esModule = true;
-exports.guard = guard;
-
-var _format = require("./format");
-
-var _result = require("./result");
-
-function guard(decoder, formatter) {
-  if (formatter === void 0) {
-    formatter = _format.formatInline;
-  }
-
-  return function (blob) {
-    return (0, _result.unwrap)((0, _result.mapError)(decoder(blob), function (annotation) {
-      var err = new Error('\n' + formatter(annotation));
-      err.name = 'Decoding error';
-      return err;
-    }));
-  };
-}

package/_guard.js.flow

@@ -1,20 +0,0 @@
-// @flow strict
-
-import { formatInline } from './format';
-import { mapError, unwrap } from './result';
-import type { Annotation } from './annotate';
-import type { Decoder, Guard } from './_types';
-
-export function guard<T>(
-    decoder: Decoder<T>,
-    formatter: (Annotation) => string = formatInline,
-): Guard<T> {
-    return (blob: mixed) =>
-        unwrap(
-            mapError(decoder(blob), (annotation) => {
-                const err = new Error('\n' + formatter(annotation));
-                err.name = 'Decoding error';
-                return err;
-            }),
-        );
-}

package/_guard.mjs

@@ -1,15 +0,0 @@
-import { formatInline } from './format.mjs';
-import { mapError, unwrap } from './result.mjs';
-export function guard(decoder, formatter) {
-  if (formatter === void 0) {
-    formatter = formatInline;
-  }
-
-  return function (blob) {
-    return unwrap(mapError(decoder(blob), function (annotation) {
-      var err = new Error('\n' + formatter(annotation));
-      err.name = 'Decoding error';
-      return err;
-    }));
-  };
-}

package/_types.d.ts

@@ -1,13 +0,0 @@
-import { Annotation } from './annotate';
-import { Result } from './result';
-
-export type Scalar = string | number | boolean | symbol | undefined | null;
-
-export type Predicate<T> = (value: T) => boolean;
-export type DecodeResult<T> = Result<T, Annotation>;
-
-export type Decoder<T, F = unknown> = (blob: F) => DecodeResult<T>;
-export type Guard<T> = (blob: unknown) => T;
-
-export type DecoderType<T> = T extends Decoder<infer V> ? V : never;
-export type GuardType<T> = T extends Guard<infer V> ? V : never;

package/_types.js

@@ -1 +0,0 @@
-"use strict";

package/_types.js.flow

@@ -1,20 +0,0 @@
-// @flow strict
-
-import type { Annotation } from './annotate';
-import type { Result } from './result';
-
-export type Scalar = string | number | boolean | symbol | void | null;
-
-export type Predicate<T> = (T) => boolean;
-export type DecodeResult<T> = Result<T, Annotation>;
-
-export type Decoder<T, F = mixed> = (F) => DecodeResult<T>;
-export type Guard<T> = (mixed) => T;
-
-/**
- * A "type function" which informs Flow about how a type will be modified at runtime.
- * Read this as "given a Guard of type T, I can produce a value of type T".  This
- * definition helps construct $ObjMap types.
- */
-export type DecoderType = <T>(Decoder<T>) => T;
-export type GuardType = <T>(Guard<T>) => T;

package/core/array.d.ts

@@ -1,8 +0,0 @@
-/// <reference lib="es6" />
-
-import { Decoder } from '../_types';
-
-export const poja: Decoder<unknown[]>;
-export function array<T>(decoder: Decoder<T>): Decoder<T[]>;
-export function nonEmptyArray<T>(decoder: Decoder<T>): Decoder<[T, ...T[]]>;
-export function set<T>(decoder: Decoder<T>): Decoder<Set<T>>;

package/core/array.js

@@ -1,115 +0,0 @@
-"use strict";
-
-exports.__esModule = true;
-exports.array = array;
-exports.nonEmptyArray = nonEmptyArray;
-exports.poja = void 0;
-exports.set = set;
-
-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.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');
-}
-/**
- * Similar to `array()`, but returns the result as an ES6 Set.
- */
-
-
-function set(decoder) {
-  return (0, _composition.transform)(array(decoder), function (items) {
-    return new Set(items);
-  });
-}

package/core/array.js.flow

@@ -1,107 +0,0 @@
-// @flow strict
-
-import { annotate } from '../annotate';
-import { compose, predicate, transform } 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.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');
-}
-
-/**
- * Similar to `array()`, but returns the result as an ES6 Set.
- */
-export function set<T>(decoder: Decoder<T>): Decoder<Set<T>> {
-    return transform(array(decoder), (items) => new Set(items));
-}

package/core/array.mjs

@@ -1,100 +0,0 @@
-import { annotate } from '../annotate.mjs';
-import { compose, predicate, transform } 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.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');
-}
-/**
- * Similar to `array()`, but returns the result as an ES6 Set.
- */
-
-export function set(decoder) {
-  return transform(array(decoder), function (items) {
-    return new Set(items);
-  });
-}

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 _number = require("./number");
-
-var _composition = require("./composition");
-
-/**
- * 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.transform)(_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 { number } from './number';
-import { transform } from './composition';
-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> = transform(number, (n) => !!n);

package/core/boolean.mjs

@@ -1,28 +0,0 @@
-import { annotate } from '../annotate.mjs';
-import { err, ok } from '../result.mjs';
-import { number } from './number.mjs';
-import { transform } from './composition.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 = transform(number, function (n) {
-  return !!n;
-});

package/core/composition.d.ts

@@ -1,18 +0,0 @@
-import { Decoder } from '../_types';
-
-export function transform<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>;
-export function prep<T, I>(
-    mapperFn: (blob: unknown) => I,
-    decoder: Decoder<T, I>,
-): Decoder<T>;