decoders 2.0.0-beta6 → 2.0.0-beta7

package/core/instanceOf.js

@@ -3,17 +3,13 @@
 exports.__esModule = true;
 exports.instanceOf = instanceOf;
 
-var Result = _interopRequireWildcard(require("../result"));
-
 var _annotate = require("../annotate");
 
-function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
-
-function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+var _result = require("../result");
 
 function instanceOf(klass) {
   return function (blob) {
-    return blob instanceof klass ? Result.ok(blob) : Result.err((0, _annotate.annotate)(blob, "Must be " + // $FlowFixMe[incompatible-use] - klass.name is fine?
+    return blob instanceof klass ? (0, _result.ok)(blob) : (0, _result.err)((0, _annotate.annotate)(blob, "Must be " + // $FlowFixMe[incompatible-use] - klass.name is fine?
     klass.name + " instance"));
   };
 }

package/core/instanceOf.js.flow

@@ -1,14 +1,14 @@
 // @flow strict
 
-import * as Result from '../result';
 import { annotate } from '../annotate';
+import { err, ok } from '../result';
 import type { Decoder } from '../_types';
 
 export function instanceOf<T>(klass: Class<T>): Decoder<T> {
     return (blob: mixed) =>
         blob instanceof klass
-            ? Result.ok(blob)
-            : Result.err(
+            ? ok(blob)
+            : err(
                   annotate(
                       blob,
                       `Must be ${

package/core/instanceOf.mjs

@@ -0,0 +1,8 @@
+import { annotate } from '../annotate.mjs';
+import { err, ok } from '../result.mjs';
+export function instanceOf(klass) {
+  return function (blob) {
+    return blob instanceof klass ? ok(blob) : err(annotate(blob, "Must be " + // $FlowFixMe[incompatible-use] - klass.name is fine?
+    klass.name + " instance"));
+  };
+}

package/core/json.d.ts

@@ -0,0 +1,11 @@
+import { Decoder } from '../_types';
+
+export type JSONValue = null | string | number | boolean | JSONObject | JSONArray;
+export interface JSONObject {
+    [key: string]: JSONValue;
+}
+export type JSONArray = JSONValue[];
+
+export const json: Decoder<JSONValue>;
+export const jsonArray: Decoder<JSONArray>;
+export const jsonObject: Decoder<JSONObject>;

package/core/json.mjs

@@ -0,0 +1,15 @@
+import { array } from './array.mjs';
+import { boolean as _boolean } from './boolean.mjs';
+import { dict } from './mapping.mjs';
+import { either6 } from './either.mjs';
+import { lazy } from './lazy.mjs';
+import { null_ } from './constants.mjs';
+import { number } from './number.mjs';
+import { string } from './string.mjs';
+export var jsonObject = lazy(function () {
+  return dict(json);
+});
+export var jsonArray = lazy(function () {
+  return array(json);
+});
+export var json = either6(null_, string, number, _boolean, jsonObject, jsonArray);

package/core/lazy.d.ts

@@ -0,0 +1,3 @@
+import { Decoder } from '../_types';
+
+export function lazy<T>(decoderFn: () => Decoder<T>): Decoder<T>;

package/core/mapping.d.ts

@@ -0,0 +1,6 @@
+/// <reference lib="es6" />
+
+import { Decoder } from '../_types';
+
+export function mapping<T>(decoder: Decoder<T>): Decoder<Map<string, T>>;
+export function dict<T>(decoder: Decoder<T>): Decoder<{ [key: string]: T }>;

package/core/mapping.js

@@ -4,17 +4,13 @@ exports.__esModule = true;
 exports.dict = dict;
 exports.mapping = mapping;
 
-var Result = _interopRequireWildcard(require("../result"));
-
 var _annotate = require("../annotate");
 
 var _composition = require("./composition");
 
-var _object = require("./object");
-
-function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+var _result = require("../result");
 
-function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+var _object = require("./object");
 
 /**
  * Given an object, will decode a Map of string keys to whatever values.
@@ -49,9 +45,9 @@ function mapping(decoder) {
     });
 
     if (errors !== null) {
-      return Result.err((0, _annotate.merge)((0, _annotate.annotateObject)(blob), errors));
+      return (0, _result.err)((0, _annotate.merge)((0, _annotate.annotateObject)(blob), errors));
     } else {
-      return Result.ok(new Map(tuples));
+      return (0, _result.ok)(new Map(tuples));
     }
   });
 }

package/core/mapping.js.flow

@@ -1,8 +1,8 @@
 // @flow strict
 
-import * as Result from '../result';
 import { annotateObject } from '../annotate';
 import { compose, map } from './composition';
+import { err, ok } from '../result';
 import { merge } from '../annotate';
 import { pojo } from './object';
 import type { Annotation } from '../annotate';
@@ -39,9 +39,9 @@ export function mapping<T>(decoder: Decoder<T>): Decoder<Map<string, T>> {
         });
 
         if (errors !== null) {
-            return Result.err(merge(annotateObject(blob), errors));
+            return err(merge(annotateObject(blob), errors));
         } else {
-            return Result.ok(new Map(tuples));
+            return ok(new Map(tuples));
         }
     });
 }

package/{_esm/core/mapping.js → core/mapping.mjs}

@@ -1,8 +1,8 @@
-import * as Result from '../result';
-import { annotateObject } from '../annotate';
-import { compose, map } from './composition';
-import { merge } from '../annotate';
-import { pojo } from './object';
+import { annotateObject } from '../annotate.mjs';
+import { compose, map } from './composition.mjs';
+import { err, ok } from '../result.mjs';
+import { merge } from '../annotate.mjs';
+import { pojo } from './object.mjs';
 
 /**
  * Given an object, will decode a Map of string keys to whatever values.
@@ -37,9 +37,9 @@ export function mapping(decoder) {
     });
 
     if (errors !== null) {
-      return Result.err(merge(annotateObject(blob), errors));
+      return err(merge(annotateObject(blob), errors));
     } else {
-      return Result.ok(new Map(tuples));
+      return ok(new Map(tuples));
     }
   });
 }

package/core/number.d.ts

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

package/core/number.js

@@ -3,18 +3,14 @@
 exports.__esModule = true;
 exports.positiveNumber = exports.positiveInteger = exports.number = exports.integer = void 0;
 
-var Result = _interopRequireWildcard(require("../result"));
-
 var _annotate = require("../annotate");
 
 var _composition = require("./composition");
 
-function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
-
-function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+var _result = require("../result");
 
 var anyNumber = function anyNumber(blob) {
-  return typeof blob === 'number' && !Number.isNaN(blob) ? Result.ok(blob) : Result.err((0, _annotate.annotate)(blob, 'Must be number'));
+  return typeof blob === 'number' && !Number.isNaN(blob) ? (0, _result.ok)(blob) : (0, _result.err)((0, _annotate.annotate)(blob, 'Must be number'));
 };
 
 var isInteger = function isInteger(n) {

package/core/number.js.flow

@@ -1,14 +1,14 @@
 // @flow strict
 
-import * as Result from '../result';
 import { annotate } from '../annotate';
 import { compose, predicate } from './composition';
+import { err, ok } from '../result';
 import type { Decoder } from '../_types';
 
 const anyNumber: Decoder<number> = (blob: mixed) => {
     return typeof blob === 'number' && !Number.isNaN(blob)
-        ? Result.ok(blob)
-        : Result.err(annotate(blob, 'Must be number'));
+        ? ok(blob)
+        : err(annotate(blob, 'Must be number'));
 };
 
 const isInteger = (n: number) => Number.isInteger(n);

package/{_esm/core/number.js → core/number.mjs}

@@ -1,9 +1,9 @@
-import * as Result from '../result';
-import { annotate } from '../annotate';
-import { compose, predicate } from './composition';
+import { annotate } from '../annotate.mjs';
+import { compose, predicate } from './composition.mjs';
+import { err, ok } from '../result.mjs';
 
 var anyNumber = function anyNumber(blob) {
-  return typeof blob === 'number' && !Number.isNaN(blob) ? Result.ok(blob) : Result.err(annotate(blob, 'Must be number'));
+  return typeof blob === 'number' && !Number.isNaN(blob) ? ok(blob) : err(annotate(blob, 'Must be number'));
 };
 
 var isInteger = function isInteger(n) {

package/core/object.d.ts

@@ -0,0 +1,33 @@
+import { Decoder, DecoderType } from '../_types';
+import { AllowImplicit } from './_helpers';
+
+export type ObjectDecoderType<T> = AllowImplicit<{
+    [key in keyof T]: DecoderType<T[key]>;
+}>;
+
+export const pojo: Decoder<{ [key: string]: unknown }>;
+
+export function object<O extends { [key: string]: Decoder<any> }>(
+    mapping: O,
+): Decoder<{ [K in keyof ObjectDecoderType<O>]: ObjectDecoderType<O>[K] }>;
+//         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+//         This is basically just equivalent to:
+//             ObjectDecoderType<O>
+//
+//         But by "resolving" this with a mapped type, we remove the helper
+//         type names from the inferred type here, making this much easier to
+//         work with while developing.
+
+export function exact<O extends { [key: string]: Decoder<any> }>(
+    mapping: O,
+): Decoder<{ [K in keyof ObjectDecoderType<O>]: ObjectDecoderType<O>[K] }>;
+//         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+//         Ditto (see above)
+
+export function inexact<O extends { [key: string]: Decoder<any> }>(
+    mapping: O,
+): Decoder<
+    { [K in keyof ObjectDecoderType<O>]: ObjectDecoderType<O>[K] } & {
+        [extra: string]: unknown;
+    }
+>;

package/core/object.js

@@ -6,15 +6,11 @@ exports.inexact = inexact;
 exports.object = object;
 exports.pojo = void 0;
 
-var Result = _interopRequireWildcard(require("../result"));
-
 var _annotate = require("../annotate");
 
 var _composition = require("./composition");
 
-function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
-
-function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+var _result = require("../result");
 
 function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
 
@@ -36,7 +32,7 @@ function subtract(xs, ys) {
 }
 
 var pojo = function pojo(blob) {
-  return isPojo(blob) ? Result.ok( // NOTE:
+  return isPojo(blob) ? (0, _result.ok)( // NOTE:
   // Since Flow 0.98, typeof o === 'object' refines to
   //     {| +[string]: mixed |}
   // instead of
@@ -50,7 +46,7 @@ var pojo = function pojo(blob) {
   // way to turn a read-only Object to a writeable one in ES6 seems
   // to be to use object-spread. (Going off this benchmark:
   // https://thecodebarbarian.com/object-assign-vs-object-spread.html)
-  _extends({}, blob)) : Result.err((0, _annotate.annotate)(blob, 'Must be an object'));
+  _extends({}, blob)) : (0, _result.err)((0, _annotate.annotate)(blob, 'Must be an object'));
 };
 /**
  * Given a mapping of fields-to-decoders, builds a decoder for an object type.
@@ -139,10 +135,10 @@ function object(mapping) {
         objAnn = (0, _annotate.updateText)(objAnn, "Missing " + pluralized + ": " + errMsg);
       }
 
-      return Result.err(objAnn);
+      return (0, _result.err)(objAnn);
     }
 
-    return Result.ok(record);
+    return (0, _result.ok)(record);
   });
 }
 
@@ -154,10 +150,10 @@ function exact(mapping) {
     var superfluous = subtract(actual, allowed);
 
     if (superfluous.size > 0) {
-      return Result.err((0, _annotate.annotate)(blob, "Superfluous keys: " + Array.from(superfluous).join(', ')));
+      return (0, _result.err)((0, _annotate.annotate)(blob, "Superfluous keys: " + Array.from(superfluous).join(', ')));
     }
 
-    return Result.ok(blob);
+    return (0, _result.ok)(blob);
   }); // Defer to the "object" decoder for doing the real decoding work.  Since
   // we made sure there are no superfluous keys in this structure, it's now
   // safe to force-cast it to an $Exact<> type.

package/core/object.js.flow

@@ -1,8 +1,8 @@
 // @flow strict
 
-import * as Result from '../result';
 import { annotate, annotateObject, merge, updateText } from '../annotate';
 import { compose, map } from './composition';
+import { err, ok } from '../result';
 import type { Annotation } from '../annotate';
 import type { Decoder, DecoderType } from '../_types';
 
@@ -36,7 +36,7 @@ function subtract(xs: Set<string>, ys: Set<string>): Set<string> {
 
 export const pojo: Decoder<{| [string]: mixed |}> = (blob: mixed) => {
     return isPojo(blob)
-        ? Result.ok(
+        ? ok(
               // NOTE:
               // Since Flow 0.98, typeof o === 'object' refines to
               //     {| +[string]: mixed |}
@@ -53,7 +53,7 @@ export const pojo: Decoder<{| [string]: mixed |}> = (blob: mixed) => {
               // https://thecodebarbarian.com/object-assign-vs-object-spread.html)
               { ...blob },
           )
-        : Result.err(annotate(blob, 'Must be an object'));
+        : err(annotate(blob, 'Must be an object'));
 };
 
 /**
@@ -144,10 +144,10 @@ export function object<O: { +[field: string]: AnyDecoder, ... }>(
                 objAnn = updateText(objAnn, `Missing ${pluralized}: ${errMsg}`);
             }
 
-            return Result.err(objAnn);
+            return err(objAnn);
         }
 
-        return Result.ok(record);
+        return ok(record);
     });
 }
 
@@ -160,11 +160,11 @@ export function exact<O: { +[field: string]: AnyDecoder, ... }>(
         const actual = new Set(Object.keys(blob));
         const superfluous = subtract(actual, allowed);
         if (superfluous.size > 0) {
-            return Result.err(
+            return err(
                 annotate(blob, `Superfluous keys: ${Array.from(superfluous).join(', ')}`),
             );
         }
-        return Result.ok(blob);
+        return ok(blob);
     });
 
     // Defer to the "object" decoder for doing the real decoding work.  Since

package/{_esm/core/object.js → core/object.mjs}

@@ -1,8 +1,8 @@
 function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
 
-import * as Result from '../result';
-import { annotate, annotateObject, merge, updateText } from '../annotate';
-import { compose, map } from './composition';
+import { annotate, annotateObject, merge, updateText } from '../annotate.mjs';
+import { compose, map } from './composition.mjs';
+import { err, ok } from '../result.mjs';
 
 function isPojo(o) {
   return o !== null && o !== undefined && typeof o === 'object' && // This still seems to be the only reliable way to determine whether
@@ -22,7 +22,7 @@ function subtract(xs, ys) {
 }
 
 export var pojo = function pojo(blob) {
-  return isPojo(blob) ? Result.ok( // NOTE:
+  return isPojo(blob) ? ok( // NOTE:
   // Since Flow 0.98, typeof o === 'object' refines to
   //     {| +[string]: mixed |}
   // instead of
@@ -36,7 +36,7 @@ export var pojo = function pojo(blob) {
   // way to turn a read-only Object to a writeable one in ES6 seems
   // to be to use object-spread. (Going off this benchmark:
   // https://thecodebarbarian.com/object-assign-vs-object-spread.html)
-  _extends({}, blob)) : Result.err(annotate(blob, 'Must be an object'));
+  _extends({}, blob)) : err(annotate(blob, 'Must be an object'));
 };
 /**
  * Given a mapping of fields-to-decoders, builds a decoder for an object type.
@@ -122,10 +122,10 @@ export function object(mapping) {
         objAnn = updateText(objAnn, "Missing " + pluralized + ": " + errMsg);
       }
 
-      return Result.err(objAnn);
+      return err(objAnn);
     }
 
-    return Result.ok(record);
+    return ok(record);
   });
 }
 export function exact(mapping) {
@@ -136,10 +136,10 @@ export function exact(mapping) {
     var superfluous = subtract(actual, allowed);
 
     if (superfluous.size > 0) {
-      return Result.err(annotate(blob, "Superfluous keys: " + Array.from(superfluous).join(', ')));
+      return err(annotate(blob, "Superfluous keys: " + Array.from(superfluous).join(', ')));
     }
 
-    return Result.ok(blob);
+    return ok(blob);
   }); // Defer to the "object" decoder for doing the real decoding work.  Since
   // we made sure there are no superfluous keys in this structure, it's now
   // safe to force-cast it to an $Exact<> type.

package/core/optional.d.ts

@@ -0,0 +1,5 @@
+import { Decoder } from '../_types';
+
+export function optional<T>(decoder: Decoder<T>): Decoder<T | undefined>;
+export function nullable<T>(decoder: Decoder<T>): Decoder<T | null>;
+export function maybe<T>(decoder: Decoder<T>): Decoder<T | null | undefined>;

package/core/optional.js

@@ -5,17 +5,13 @@ exports.maybe = maybe;
 exports.nullable = nullable;
 exports.optional = optional;
 
-var Result = _interopRequireWildcard(require("../result"));
-
 var _annotate = require("../annotate");
 
 var _either = require("./either");
 
-var _constants = require("./constants");
-
-function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+var _result = require("../result");
 
-function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+var _constants = require("./constants");
 
 /**
  * Builds a Decoder that returns Ok for either `undefined` or `T` values,
@@ -41,8 +37,8 @@ function nullable(decoder) {
 
 
 var undefined_or_null = function undefined_or_null(blob) {
-  return blob === undefined || blob === null ? Result.ok(blob) : // Combine error message into a single line
-  Result.err((0, _annotate.annotate)(blob, 'Must be undefined or null'));
+  return blob === undefined || blob === null ? (0, _result.ok)(blob) : // Combine error message into a single line
+  (0, _result.err)((0, _annotate.annotate)(blob, 'Must be undefined or null'));
 };
 /**
  * Decoder that only returns Ok for `null` or `undefined` inputs.

package/core/optional.js.flow

@@ -1,8 +1,8 @@
 // @flow strict
 
-import * as Result from '../result';
 import { annotate } from '../annotate';
 import { either } from './either';
+import { err, ok } from '../result';
 import { null_, undefined_ } from './constants';
 import type { Decoder } from '../_types';
 
@@ -29,9 +29,9 @@ export function nullable<T>(decoder: Decoder<T>): Decoder<null | T> {
  */
 const undefined_or_null: Decoder<null | void> = (blob: mixed) =>
     blob === undefined || blob === null
-        ? Result.ok(blob)
+        ? ok(blob)
         : // Combine error message into a single line
-          Result.err(annotate(blob, 'Must be undefined or null'));
+          err(annotate(blob, 'Must be undefined or null'));
 
 /**
  * Decoder that only returns Ok for `null` or `undefined` inputs.

package/{_esm/core/optional.js → core/optional.mjs}

@@ -1,7 +1,7 @@
-import * as Result from '../result';
-import { annotate } from '../annotate';
-import { either } from './either';
-import { null_, undefined_ } from './constants';
+import { annotate } from '../annotate.mjs';
+import { either } from './either.mjs';
+import { err, ok } from '../result.mjs';
+import { null_, undefined_ } from './constants.mjs';
 
 /**
  * Builds a Decoder that returns Ok for either `undefined` or `T` values,
@@ -25,8 +25,8 @@ export function nullable(decoder) {
  */
 
 var undefined_or_null = function undefined_or_null(blob) {
-  return blob === undefined || blob === null ? Result.ok(blob) : // Combine error message into a single line
-  Result.err(annotate(blob, 'Must be undefined or null'));
+  return blob === undefined || blob === null ? ok(blob) : // Combine error message into a single line
+  err(annotate(blob, 'Must be undefined or null'));
 };
 /**
  * Decoder that only returns Ok for `null` or `undefined` inputs.

package/core/string.d.ts

@@ -0,0 +1,7 @@
+import { Decoder } from '../_types';
+
+export const string: Decoder<string>;
+export const nonEmptyString: Decoder<string>;
+export function regex(regex: RegExp, msg: string): Decoder<string>;
+export const email: Decoder<string>;
+export function url(schemes?: readonly string[]): Decoder<string>;

package/core/string.js

@@ -5,15 +5,11 @@ exports.nonEmptyString = exports.email = void 0;
 exports.regex = regex;
 exports.url = exports.string = void 0;
 
-var Result = _interopRequireWildcard(require("../result"));
-
 var _annotate = require("../annotate");
 
 var _composition = require("./composition");
 
-function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
-
-function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+var _result = require("../result");
 
 /** Match groups in this regex:
  * \1 - the scheme
@@ -30,7 +26,7 @@ var DEFAULT_SCHEMES = ['https'];
  */
 
 var string = function string(blob) {
-  return typeof blob === 'string' ? Result.ok(blob) : Result.err((0, _annotate.annotate)(blob, 'Must be string'));
+  return typeof blob === 'string' ? (0, _result.ok)(blob) : (0, _result.err)((0, _annotate.annotate)(blob, 'Must be string'));
 };
 /**
  * Decoder that only returns Ok for non-empty string inputs.  Err otherwise.
@@ -82,14 +78,14 @@ var url = function url(schemes) {
     var matches = value.match(url_re);
 
     if (!matches) {
-      return Result.err((0, _annotate.annotate)(value, 'Must be URL'));
+      return (0, _result.err)((0, _annotate.annotate)(value, 'Must be URL'));
     } else {
       var scheme = matches[1];
 
       if (schemes.length === 0 || schemes.includes(scheme.toLowerCase())) {
-        return Result.ok(value);
+        return (0, _result.ok)(value);
       } else {
-        return Result.err((0, _annotate.annotate)(value, "URL scheme must be any of: " + schemes.join(', ')));
+        return (0, _result.err)((0, _annotate.annotate)(value, "URL scheme must be any of: " + schemes.join(', ')));
       }
     }
   });

package/core/string.js.flow

@@ -1,8 +1,8 @@
 // @flow strict
 
-import * as Result from '../result';
 import { annotate } from '../annotate';
 import { compose, predicate } from './composition';
+import { err, ok } from '../result';
 import type { Decoder } from '../_types';
 
 /** Match groups in this regex:
@@ -22,9 +22,7 @@ const DEFAULT_SCHEMES = ['https'];
  * Decoder that only returns Ok for string inputs.  Err otherwise.
  */
 export const string: Decoder<string> = (blob: mixed) => {
-    return typeof blob === 'string'
-        ? Result.ok(blob)
-        : Result.err(annotate(blob, 'Must be string'));
+    return typeof blob === 'string' ? ok(blob) : err(annotate(blob, 'Must be string'));
 };
 
 /**
@@ -68,13 +66,13 @@ export const url = (schemes: $ReadOnlyArray<string> = DEFAULT_SCHEMES): Decoder<
     compose(string, (value: string) => {
         const matches = value.match(url_re);
         if (!matches) {
-            return Result.err(annotate(value, 'Must be URL'));
+            return err(annotate(value, 'Must be URL'));
         } else {
             const scheme = matches[1];
             if (schemes.length === 0 || schemes.includes(scheme.toLowerCase())) {
-                return Result.ok(value);
+                return ok(value);
             } else {
-                return Result.err(
+                return err(
                     annotate(value, `URL scheme must be any of: ${schemes.join(', ')}`),
                 );
             }