decoders 2.0.0-beta8 → 2.0.1

package/lib/utilities.mjs

@@ -0,0 +1,37 @@
+import { annotate } from '../annotate.mjs'
+import { define } from '../Decoder.mjs'
+
+export function instanceOf(klass) {
+  return define(function (blob, ok, err) {
+    return blob instanceof klass ? ok(blob) : err('Must be ' + klass.name + ' instance')
+  })
+}
+
+export function lazy(decoderFn) {
+  return define(function (blob) {
+    return decoderFn().decode(blob)
+  })
+}
+
+export function prep(mapperFn, decoder) {
+  return define(function (originalInput, _, err) {
+    var blob
+
+    try {
+      blob = mapperFn(originalInput)
+    } catch (e) {
+      return err(annotate(originalInput, e.message))
+    }
+
+    var r = decoder.decode(blob)
+    return r.ok ? r : err(annotate(originalInput, r.error.text))
+  })
+}
+
+export function never(msg) {
+  return define(function (_, __, err) {
+    return err(msg)
+  })
+}
+
+export var fail = never

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "decoders",
-    "version": "2.0.0-beta8",
+    "version": "2.0.1",
     "description": "Elegant and battle-tested validation library for type-safe input data (for TypeScript and Flow)",
     "license": "MIT",
     "repository": {
@@ -15,30 +15,77 @@
     "main": "./index.js",
     "module": "./index.mjs",
     "keywords": [
-        "decoder",
         "decoders",
-        "guard",
-        "object",
+        "Decoder",
+        "always",
+        "and",
         "array",
-        "string",
-        "email",
-        "regex",
-        "number",
-        "integer",
         "boolean",
-        "truthy",
+        "then",
+        "compose",
+        "constant",
         "date",
-        "mapping",
+        "decode",
+        "decoder",
+        "decoders",
+        "define",
+        "describe",
         "dict",
+        "either",
+        "email",
+        "exact",
+        "fail",
+        "hardcoded",
+        "httpsUrl",
+        "inexact",
+        "instanceOf",
+        "integer",
+        "iso8601",
+        "json",
+        "jsonArray",
+        "jsonObject",
+        "lazy",
+        "map",
+        "mapping",
+        "maybe",
         "mixed",
+        "mixedarray",
+        "never",
+        "nonEmptyArray",
+        "nonEmptyString",
+        "nullable",
+        "null_",
+        "number",
+        "numericBoolean",
+        "object",
+        "oneOf",
+        "optional",
+        "poja",
+        "pojo",
+        "positiveInteger",
+        "positiveNumber",
+        "predicate",
+        "prep",
+        "regex",
+        "set",
+        "string",
+        "taggedUnion",
+        "transform",
+        "truthy",
+        "tuple",
         "tuple2",
+        "undefined_",
         "unknown",
-        "optional",
-        "nullable",
-        "maybe",
-        "compose",
-        "map",
-        "predicate"
+        "url",
+        "uuid",
+        "uuidv1",
+        "uuidv4",
+        "verify",
+        "DecodeResult",
+        "DecoderType",
+        "JSONArray",
+        "JSONObject",
+        "JSONValue"
     ],
     "githubUrl": "https://github.com/nvie/decoders",
     "sideEffects": false,

package/result.d.ts

@@ -1,11 +1,11 @@
 export interface Ok<T> {
-    type: 'ok';
+    ok: true;
     value: T;
     error: undefined;
 }
 
 export interface Err<E> {
-    type: 'err';
+    ok: false;
     value: undefined;
     error: E;
 }
@@ -14,26 +14,3 @@ export type Result<T, E> = Ok<T> | Err<E>;
 
 export function ok<T>(value: T): Ok<T>;
 export function err<E>(error: E): Err<E>;
-export function unwrap<T>(result: Result<T, unknown>): T;
-export function expect<T>(result: Result<T, unknown>, message: string | Error): T;
-export function dispatch<T, E, O>(
-    result: Result<T, E>,
-    okCallback: (value: T) => O,
-    errCallback: (error: E) => O,
-): O;
-export function andThen<T, E, T2>(
-    result1: Result<T, E>,
-    lazyResult2: (value: T) => Result<T2, E>,
-): Result<T2, E>;
-export function orElse<T, E, E2>(
-    result1: Result<T, E>,
-    lazyResult2: (errValue: E) => Result<T, E2>,
-): Result<T, E2>;
-export function mapOk<T, E, T2>(
-    result: Result<T, E>,
-    mapper: (value: T) => T2,
-): Result<T2, E>;
-export function mapError<T, E, E2>(
-    result: Result<T, E>,
-    mapper: (error: E) => E2,
-): Result<T, E2>;

package/result.js

@@ -1,102 +1,21 @@
-"use strict";
+'use strict'
 
-exports.__esModule = true;
-exports.andThen = andThen;
-exports.dispatch = dispatch;
-exports.err = err;
-exports.expect = expect;
-exports.mapError = mapError;
-exports.mapOk = mapOk;
-exports.ok = ok;
-exports.orElse = orElse;
-exports.unwrap = unwrap;
+exports.__esModule = true
+exports.err = err
+exports.ok = ok
 
-/**
- * Result <value> <error>
- *     = Ok <value>
- *     | Err <error>
- */
-
-/**
- * Create a new Result instance representing a successful computation.
- */
 function ok(value) {
   return {
-    type: 'ok',
+    ok: true,
     value: value,
-    error: undefined
-  };
+    error: undefined,
+  }
 }
-/**
- * Create a new Result instance representing a failed computation.
- */
-
 
 function err(error) {
   return {
-    type: 'err',
+    ok: false,
     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.
- */
-
-
-function unwrap(result) {
-  if (result.type === 'ok') {
-    return result.value;
-  } else {
-    throw result.error;
+    error: error,
   }
 }
-
-function expect(result, message) {
-  if (result.type === 'ok') {
-    return result.value;
-  } else {
-    throw message instanceof Error ? message : new Error(message);
-  }
-}
-
-function dispatch(result, okCallback, errCallback) {
-  return result.type === '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.
- */
-
-
-function andThen(result1, lazyResult2) {
-  return result1.type === '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.
- */
-
-
-function orElse(result1, lazyResult2) {
-  return result1.type === 'ok' ? result1 : lazyResult2(result1.error);
-}
-/**
- * Transform an Ok result. Will not touch Err results.
- */
-
-
-function mapOk(result, mapper) {
-  return result.type === 'ok' ? ok(mapper(result.value)) : result;
-}
-/**
- * Transform an Err value. Will not touch Ok results.
- */
-
-
-function mapError(result, mapper) {
-  return result.type === 'ok' ? result : err(mapper(result.error));
-}

package/result.js.flow

@@ -6,8 +6,8 @@
  *     | Err <error>
  */
 
-type Ok<+T> = {| +type: 'ok', +value: T, +error: void |};
-type Err<+E> = {| +type: 'err', +value: void, +error: E |};
+type Ok<+T> = {| +ok: true, +value: T, +error: void |};
+type Err<+E> = {| +ok: false, +value: void, +error: E |};
 
 export type Result<+T, +E> = Ok<T> | Err<E>;
 
@@ -15,84 +15,12 @@ export type Result<+T, +E> = Ok<T> | Err<E>;
  * Create a new Result instance representing a successful computation.
  */
 export function ok<T>(value: T): Ok<T> {
-    return { type: 'ok', value, error: undefined };
+    return { ok: true, value, error: undefined };
 }
 
 /**
  * Create a new Result instance representing a failed computation.
  */
 export function err<E>(error: E): Err<E> {
-    return { type: 'err', value: undefined, 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<T>(result: Result<T, mixed>): T {
-    if (result.type === 'ok') {
-        return result.value;
-    } else {
-        throw result.error;
-    }
-}
-
-export function expect<T>(result: Result<T, mixed>, message: string | Error): T {
-    if (result.type === 'ok') {
-        return result.value;
-    } else {
-        throw message instanceof Error ? message : new Error(message);
-    }
-}
-
-export function dispatch<T, E, O>(
-    result: Result<T, E>,
-    okCallback: (value: T) => O,
-    errCallback: (error: E) => O,
-): O {
-    return result.type === '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<T, E, T2>(
-    result1: Result<T, E>,
-    lazyResult2: (value: T) => Result<T2, E>,
-): Result<T2, E> {
-    return result1.type === '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<T, E, E2>(
-    result1: Result<T, E>,
-    lazyResult2: (errValue: E) => Result<T, E2>,
-): Result<T, E2> {
-    return result1.type === 'ok' ? result1 : lazyResult2(result1.error);
-}
-
-/**
- * Transform an Ok result. Will not touch Err results.
- */
-export function mapOk<T, E, T2>(
-    result: Result<T, E>,
-    mapper: (value: T) => T2,
-): Result<T2, E> {
-    return result.type === 'ok' ? ok(mapper(result.value)) : result;
-}
-
-/**
- * Transform an Err value. Will not touch Ok results.
- */
-export function mapError<T, E, E2>(
-    result: Result<T, E>,
-    mapper: (error: E) => E2,
-): Result<T, E2> {
-    return result.type === 'ok' ? result : err(mapper(result.error));
+    return { ok: false, value: undefined, error };
 }

package/result.mjs

@@ -1,81 +1,15 @@
-/**
- * Result <value> <error>
- *     = Ok <value>
- *     | Err <error>
- */
-
-/**
- * Create a new Result instance representing a successful computation.
- */
 export function ok(value) {
   return {
-    type: 'ok',
+    ok: true,
     value: value,
-    error: undefined
-  };
+    error: undefined,
+  }
 }
-/**
- * Create a new Result instance representing a failed computation.
- */
 
 export function err(error) {
   return {
-    type: 'err',
+    ok: false,
     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.type === 'ok') {
-    return result.value;
-  } else {
-    throw result.error;
+    error: error,
   }
 }
-export function expect(result, message) {
-  if (result.type === 'ok') {
-    return result.value;
-  } else {
-    throw message instanceof Error ? message : new Error(message);
-  }
-}
-export function dispatch(result, okCallback, errCallback) {
-  return result.type === '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.type === '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.type === 'ok' ? result1 : lazyResult2(result1.error);
-}
-/**
- * Transform an Ok result. Will not touch Err results.
- */
-
-export function mapOk(result, mapper) {
-  return result.type === 'ok' ? ok(mapper(result.value)) : result;
-}
-/**
- * Transform an Err value. Will not touch Ok results.
- */
-
-export function mapError(result, mapper) {
-  return result.type === '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,5 +0,0 @@
-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[]]>;