decoders 2.0.0-beta10 → 2.0.0-beta11

package/Decoder.d.ts

@@ -11,8 +11,9 @@ export type DecodeFn<T, I = unknown> = (
 ) => DecodeResult<T>;
 
 export interface Decoder<T> {
-    decode(blob: unknown): DecodeResult<T>;
     verify(blob: unknown, formatterFn?: (ann: Annotation) => string): T;
+    value(blob: unknown): T | undefined;
+    decode(blob: unknown): DecodeResult<T>;
     refine<N extends T>(predicate: (value: T) => value is N, msg: string): Decoder<N>;
     refine(predicate: (value: T) => boolean, msg: string): Decoder<T>;
     reject(rejectFn: (value: T) => string | Annotation | null): Decoder<T>;

package/Decoder.js

@@ -24,7 +24,7 @@ function noThrow(fn) {
  * The function receives three arguments:
  *
  * 1. `blob` - the raw/unknown input (aka your external data)
- * 2. `ok` - Call `ok(value)` to accept the input and return `value`
+ * 2. `ok` - Call `ok(value)` to accept the input and return ``value``
  * 3. `err` - Call `err(message)` to reject the input and use "message" in the
  *    annotation
  *
@@ -70,6 +70,19 @@ function define(decodeFn) {
       throw _err;
     }
   }
+  /**
+   * Verified the (raw/untrusted/unknown) input and either accepts or rejects
+   * it. When accepted, returns the decoded `T` value directly. Otherwise
+   * returns `undefined`.
+   *
+   * Use this when you're not interested in programmatically handling the
+   * error message.
+   */
+
+
+  function value(blob) {
+    return decode(blob).value;
+  }
   /**
    * Accepts any value the given decoder accepts, and on success, will call
    * the given function **on the decoded result**. If the transformation
@@ -187,6 +200,7 @@ function define(decodeFn) {
 
   return Object.freeze({
     verify: verify,
+    value: value,
     decode: decode,
     transform: transform,
     refine: refine,

package/Decoder.js.flow

@@ -32,8 +32,9 @@ export type DecodeFn<T, I = mixed> = (
 export type DecoderType<D> = $Call<<T>(Decoder<T>) => T, D>;
 
 export type Decoder<T> = {|
-    decode(blob: mixed): DecodeResult<T>,
     verify(blob: mixed, formatterFn?: (Annotation) => string): T,
+    value(blob: mixed): T | void,
+    decode(blob: mixed): DecodeResult<T>,
     refine(predicateFn: (value: T) => boolean, errmsg: string): Decoder<T>,
     reject(rejectFn: (value: T) => string | Annotation | null): Decoder<T>,
     transform<V>(transformFn: (value: T) => V): Decoder<V>,
@@ -60,7 +61,7 @@ function noThrow<T, V>(fn: (value: T) => V): (T) => DecodeResult<V> {
  * The function receives three arguments:
  *
  * 1. `blob` - the raw/unknown input (aka your external data)
- * 2. `ok` - Call `ok(value)` to accept the input and return `value`
+ * 2. `ok` - Call `ok(value)` to accept the input and return ``value``
  * 3. `err` - Call `err(message)` to reject the input and use "message" in the
  *    annotation
  *
@@ -98,6 +99,18 @@ export function define<T>(decodeFn: DecodeFn<T>): Decoder<T> {
         }
     }
 
+    /**
+     * Verified the (raw/untrusted/unknown) input and either accepts or rejects
+     * it. When accepted, returns the decoded `T` value directly. Otherwise
+     * returns `undefined`.
+     *
+     * Use this when you're not interested in programmatically handling the
+     * error message.
+     */
+    function value(blob: mixed): T | void {
+        return decode(blob).value;
+    }
+
     /**
      * Accepts any value the given decoder accepts, and on success, will call
      * the given function **on the decoded result**. If the transformation
@@ -211,6 +224,7 @@ export function define<T>(decodeFn: DecodeFn<T>): Decoder<T> {
 
     return Object.freeze({
         verify,
+        value,
         decode,
         transform,
         refine,

package/Decoder.mjs

@@ -17,7 +17,7 @@ function noThrow(fn) {
  * The function receives three arguments:
  *
  * 1. `blob` - the raw/unknown input (aka your external data)
- * 2. `ok` - Call `ok(value)` to accept the input and return `value`
+ * 2. `ok` - Call `ok(value)` to accept the input and return ``value``
  * 3. `err` - Call `err(message)` to reject the input and use "message" in the
  *    annotation
  *
@@ -63,6 +63,19 @@ export function define(decodeFn) {
       throw _err;
     }
   }
+  /**
+   * Verified the (raw/untrusted/unknown) input and either accepts or rejects
+   * it. When accepted, returns the decoded `T` value directly. Otherwise
+   * returns `undefined`.
+   *
+   * Use this when you're not interested in programmatically handling the
+   * error message.
+   */
+
+
+  function value(blob) {
+    return decode(blob).value;
+  }
   /**
    * Accepts any value the given decoder accepts, and on success, will call
    * the given function **on the decoded result**. If the transformation
@@ -180,6 +193,7 @@ export function define(decodeFn) {
 
   return Object.freeze({
     verify: verify,
+    value: value,
     decode: decode,
     transform: transform,
     refine: refine,

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "decoders",
-    "version": "2.0.0-beta10",
+    "version": "2.0.0-beta11",
     "description": "Elegant and battle-tested validation library for type-safe input data (for TypeScript and Flow)",
     "license": "MIT",
     "repository": {