decoders 2.0.0-beta8 → 2.0.1

package/_utils.d.ts

@@ -1,6 +1,5 @@
 import { Annotation } from './annotate';
 
-export function isDate(value: unknown): boolean;
 export function asDate(value: unknown): Date | null;
 export function isMultiline(s: string): boolean;
 export function indent(s: string, prefix?: string): string;

package/_utils.js

@@ -1,108 +1,91 @@
-"use strict";
-
-exports.__esModule = true;
-exports.INDENT = void 0;
-exports.asDate = asDate;
-exports.indent = indent;
-exports.isDate = isDate;
-exports.isMultiline = isMultiline;
-exports.summarize = summarize;
-// $FlowFixMe[unclear-type] - deliberate casting
-// Two spaces of indentation
-var INDENT = '  ';
-/**
- * `x instanceof Date` checks are unreliable across stack frames (that information
- * might get lost by the JS runtime), so we'll have to reside to more runtime
- * inspection checks.
- *
- * Taken from https://stackoverflow.com/a/44198641
- */
-
-exports.INDENT = INDENT;
-
-function isDate(value) {
-  return !!value && // $FlowFixMe[method-unbinding]
-  Object.prototype.toString.call(value) === '[object Date]' && !isNaN(value);
+'use strict'
+
+exports.__esModule = true
+exports.INDENT = void 0
+exports.asDate = asDate
+exports.indent = indent
+exports.isMultiline = isMultiline
+exports.subtract = subtract
+exports.summarize = summarize
+var INDENT = '  '
+
+exports.INDENT = INDENT
+
+function subtract(xs, ys) {
+  var result = new Set()
+  xs.forEach(function (x) {
+    if (!ys.has(x)) {
+      result.add(x)
+    }
+  })
+  return result
 }
-/**
- * Is value is a valid Date instance, then return that.  If not, then return
- * null.
- */
-
 
 function asDate(value) {
-  return isDate(value) ? value : null;
+  return !!value && Object.prototype.toString.call(value) === '[object Date]' && !isNaN(value) ? value : null
 }
 
 function isMultiline(s) {
-  return s.indexOf('\n') >= 0;
+  return s.indexOf('\n') >= 0
 }
 
 function indent(s, prefix) {
   if (prefix === void 0) {
-    prefix = INDENT;
+    prefix = INDENT
   }
 
   if (isMultiline(s)) {
-    return s.split('\n').map(function (line) {
-      return prefix + line;
-    }).join('\n');
+    return s
+      .split('\n')
+      .map(function (line) {
+        return '' + prefix + line
+      })
+      .join('\n')
   } else {
-    return prefix + s;
+    return '' + prefix + s
   }
 }
-/**
- * Walks the annotation tree and emits the annotation's key path within the
- * object tree, and the message as a series of messages (array of strings).
- */
-
 
 function summarize(ann, keypath) {
   if (keypath === void 0) {
-    keypath = [];
+    keypath = []
   }
 
-  var result = [];
+  var result = []
 
   if (ann.type === 'array') {
-    var items = ann.items;
-    var index = 0;
+    var items = ann.items
+    var index = 0
     items.forEach(function (ann) {
       summarize(ann, [].concat(keypath, [index++])).forEach(function (item) {
-        return (// Collect to results
-          result.push(item)
-        );
-      });
-    });
+        return result.push(item)
+      })
+    })
   } else if (ann.type === 'object') {
-    var fields = ann.fields;
+    var fields = ann.fields
     Object.keys(fields).forEach(function (key) {
-      var value = fields[key];
+      var value = fields[key]
       summarize(value, [].concat(keypath, [key])).forEach(function (item) {
-        return (// Collect to results
-          result.push(item)
-        );
-      });
-    });
+        return result.push(item)
+      })
+    })
   }
 
-  var text = ann.text;
+  var text = ann.text
 
   if (!text) {
-    return result;
+    return result
   }
 
-  var prefix;
+  var prefix
 
   if (keypath.length === 0) {
-    prefix = '';
+    prefix = ''
   } else if (keypath.length === 1) {
-    prefix = typeof keypath[0] === 'number' ? "Value at index " + keypath[0] + ": " : "Value at key " + JSON.stringify(keypath[0]) + ": ";
+    prefix = typeof keypath[0] === 'number' ? 'Value at index ' + keypath[0] + ': ' : 'Value at key ' + JSON.stringify(keypath[0]) + ': '
   } else {
-    prefix = "Value at keypath " + keypath.map(function (x) {
-      return x.toString();
-    }).join('.') + ": ";
+    prefix = 'Value at keypath ' + keypath.map(String).join('.') + ': '
   }
 
-  return [].concat(result, [prefix + text]);
-}
+  return [].concat(result, ['' + prefix + text])
+}

package/_utils.js.flow

@@ -1,35 +1,45 @@
 // @flow strict
 
 import type { Annotation } from './annotate';
+import type { Scalar } from './Decoder';
 
-// $FlowFixMe[unclear-type] - deliberate casting
-type cast = any;
+// $FlowFixMe[unclear-type] - deliberate use of `any`
+export type _Any = any;
 
 // Two spaces of indentation
 export const INDENT = '  ';
 
 /**
- * `x instanceof Date` checks are unreliable across stack frames (that information
- * might get lost by the JS runtime), so we'll have to reside to more runtime
- * inspection checks.
- *
- * Taken from https://stackoverflow.com/a/44198641
+ * Subtract two sets. Why isn't this a standard method on Sets?
  */
-export function isDate(value: mixed): boolean {
-    return (
-        !!value &&
-        // $FlowFixMe[method-unbinding]
-        Object.prototype.toString.call(value) === '[object Date]' &&
-        !isNaN(value)
-    );
+export function subtract<T: Scalar>(xs: Set<T>, ys: Set<T>): Set<T> {
+    const result = new Set();
+    xs.forEach((x) => {
+        if (!ys.has(x)) {
+            result.add(x);
+        }
+    });
+    return result;
 }
 
 /**
- * Is value is a valid Date instance, then return that.  If not, then return
+ * Is value is a valid Date instance, then return that. If not, then return
  * null.
  */
 export function asDate(value: mixed): Date | null {
-    return isDate(value) ? ((value: cast): Date) : null;
+    //
+    // `x instanceof Date` checks are unreliable across stack frames (that
+    // information might get lost by the JS runtime), so we'll have to reside
+    // to more runtime inspection checks.
+    //
+    // Taken from https://stackoverflow.com/a/44198641
+    //
+    return !!value &&
+        // $FlowFixMe[method-unbinding]
+        Object.prototype.toString.call(value) === '[object Date]' &&
+        !isNaN(value)
+        ? ((value: _Any): Date)
+        : null;
 }
 
 export function isMultiline(s: string): boolean {
@@ -40,10 +50,10 @@ export function indent(s: string, prefix: string = INDENT): string {
     if (isMultiline(s)) {
         return s
             .split('\n')
-            .map((line) => prefix + line)
+            .map((line) => `${prefix}${line}`)
             .join('\n');
     } else {
-        return prefix + s;
+        return `${prefix}${s}`;
     }
 }
 
@@ -91,7 +101,7 @@ export function summarize(
                 ? `Value at index ${keypath[0]}: `
                 : `Value at key ${JSON.stringify(keypath[0])}: `;
     } else {
-        prefix = `Value at keypath ${keypath.map((x) => x.toString()).join('.')}: `;
+        prefix = `Value at keypath ${keypath.map(String).join('.')}: `;
     }
-    return [...result, prefix + text];
+    return [...result, `${prefix}${text}`];
 }

package/_utils.mjs

@@ -1,93 +1,78 @@
-// $FlowFixMe[unclear-type] - deliberate casting
-// Two spaces of indentation
-export var INDENT = '  ';
-/**
- * `x instanceof Date` checks are unreliable across stack frames (that information
- * might get lost by the JS runtime), so we'll have to reside to more runtime
- * inspection checks.
- *
- * Taken from https://stackoverflow.com/a/44198641
- */
+export var INDENT = '  '
 
-export function isDate(value) {
-  return !!value && // $FlowFixMe[method-unbinding]
-  Object.prototype.toString.call(value) === '[object Date]' && !isNaN(value);
+export function subtract(xs, ys) {
+  var result = new Set()
+  xs.forEach(function (x) {
+    if (!ys.has(x)) {
+      result.add(x)
+    }
+  })
+  return result
 }
-/**
- * Is value is a valid Date instance, then return that.  If not, then return
- * null.
- */
 
 export function asDate(value) {
-  return isDate(value) ? value : null;
+  return !!value && Object.prototype.toString.call(value) === '[object Date]' && !isNaN(value) ? value : null
 }
 export function isMultiline(s) {
-  return s.indexOf('\n') >= 0;
+  return s.indexOf('\n') >= 0
 }
 export function indent(s, prefix) {
   if (prefix === void 0) {
-    prefix = INDENT;
+    prefix = INDENT
   }
 
   if (isMultiline(s)) {
-    return s.split('\n').map(function (line) {
-      return prefix + line;
-    }).join('\n');
+    return s
+      .split('\n')
+      .map(function (line) {
+        return '' + prefix + line
+      })
+      .join('\n')
   } else {
-    return prefix + s;
+    return '' + prefix + s
   }
 }
-/**
- * Walks the annotation tree and emits the annotation's key path within the
- * object tree, and the message as a series of messages (array of strings).
- */
 
 export function summarize(ann, keypath) {
   if (keypath === void 0) {
-    keypath = [];
+    keypath = []
   }
 
-  var result = [];
+  var result = []
 
   if (ann.type === 'array') {
-    var items = ann.items;
-    var index = 0;
+    var items = ann.items
+    var index = 0
     items.forEach(function (ann) {
       summarize(ann, [].concat(keypath, [index++])).forEach(function (item) {
-        return (// Collect to results
-          result.push(item)
-        );
-      });
-    });
+        return result.push(item)
+      })
+    })
   } else if (ann.type === 'object') {
-    var fields = ann.fields;
+    var fields = ann.fields
     Object.keys(fields).forEach(function (key) {
-      var value = fields[key];
+      var value = fields[key]
       summarize(value, [].concat(keypath, [key])).forEach(function (item) {
-        return (// Collect to results
-          result.push(item)
-        );
-      });
-    });
+        return result.push(item)
+      })
+    })
   }
 
-  var text = ann.text;
+  var text = ann.text
 
   if (!text) {
-    return result;
+    return result
   }
 
-  var prefix;
+  var prefix
 
   if (keypath.length === 0) {
-    prefix = '';
+    prefix = ''
   } else if (keypath.length === 1) {
-    prefix = typeof keypath[0] === 'number' ? "Value at index " + keypath[0] + ": " : "Value at key " + JSON.stringify(keypath[0]) + ": ";
+    prefix = typeof keypath[0] === 'number' ? 'Value at index ' + keypath[0] + ': ' : 'Value at key ' + JSON.stringify(keypath[0]) + ': '
   } else {
-    prefix = "Value at keypath " + keypath.map(function (x) {
-      return x.toString();
-    }).join('.') + ": ";
+    prefix = 'Value at keypath ' + keypath.map(String).join('.') + ': '
   }
 
-  return [].concat(result, [prefix + text]);
-}
+  return [].concat(result, ['' + prefix + text])
+}

package/annotate.js

@@ -1,161 +1,168 @@
-"use strict";
-
-exports.__esModule = true;
-exports.__private_annotate = annotate;
-exports.annotate = public_annotate;
-exports.annotateObject = public_annotateObject;
-exports.array = array;
-exports.asAnnotation = asAnnotation;
-exports.circularRef = circularRef;
-exports.func = func;
-exports.merge = merge;
-exports.object = object;
-exports.scalar = scalar;
-exports.unknown = unknown;
-exports.updateText = updateText;
-
-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); }
-
-var _register = new WeakSet();
+'use strict'
+
+exports.__esModule = true
+exports.__private_annotate = annotate
+exports.annotate = public_annotate
+exports.annotateObject = public_annotateObject
+exports.array = array
+exports.asAnnotation = asAnnotation
+exports.circularRef = circularRef
+exports.func = func
+exports.merge = merge
+exports.object = object
+exports.scalar = scalar
+exports.unknown = unknown
+exports.updateText = updateText
+
+function _extends() {
+  _extends = Object.assign
+    ? Object.assign.bind()
+    : 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)
+}
+
+var _register = new WeakSet()
 
 function brand(ann) {
-  _register.add(ann);
+  _register.add(ann)
 
-  return ann;
+  return ann
 }
 
 function object(fields, text) {
   return brand({
     type: 'object',
     fields: fields,
-    text: text
-  });
+    text: text,
+  })
 }
 
 function array(items, text) {
   return brand({
     type: 'array',
     items: items,
-    text: text
-  });
+    text: text,
+  })
 }
 
 function func(text) {
   return brand({
     type: 'function',
-    text: text
-  });
+    text: text,
+  })
 }
 
 function unknown(value, text) {
   return brand({
     type: 'unknown',
     value: value,
-    text: text
-  });
+    text: text,
+  })
 }
 
 function scalar(value, text) {
   return brand({
     type: 'scalar',
     value: value,
-    text: text
-  });
+    text: text,
+  })
 }
 
 function circularRef(text) {
   return brand({
     type: 'circular-ref',
-    text: text
-  });
+    text: text,
+  })
 }
-/**
- * Given an existing Annotation, set the annotation's text to a new value.
- */
-
 
 function updateText(annotation, text) {
   if (text !== undefined) {
-    return brand(_extends({}, annotation, {
-      text: text
-    }));
+    return brand(
+      _extends({}, annotation, {
+        text: text,
+      })
+    )
   } else {
-    return annotation;
+    return annotation
   }
 }
-/**
- * Given an existing ObjectAnnotation, merges new Annotations in there.
- */
-
 
 function merge(objAnnotation, fields) {
-  var newFields = _extends({}, objAnnotation.fields, fields);
+  var newFields = _extends({}, objAnnotation.fields, fields)
 
-  return object(newFields, objAnnotation.text);
+  return object(newFields, objAnnotation.text)
 }
 
 function asAnnotation(thing) {
-  return typeof thing === 'object' && thing !== null && _register.has(thing) ? thing : undefined;
+  return typeof thing === 'object' && thing !== null && _register.has(thing) ? thing : undefined
 }
 
 function annotateArray(value, text, seen) {
-  seen.add(value);
+  seen.add(value)
   var items = value.map(function (v) {
-    return annotate(v, undefined, seen);
-  });
-  return array(items, text);
+    return annotate(v, undefined, seen)
+  })
+  return array(items, text)
 }
 
 function annotateObject(obj, text, seen) {
-  seen.add(obj);
-  var fields = {};
+  seen.add(obj)
+  var fields = {}
   Object.keys(obj).forEach(function (key) {
-    var value = obj[key];
-    fields[key] = annotate(value, undefined, seen);
-  });
-  return object(fields, text);
+    var value = obj[key]
+    fields[key] = annotate(value, undefined, seen)
+  })
+  return object(fields, text)
 }
 
 function annotate(value, text, seen) {
   if (value === null || value === undefined || typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean' || typeof value === 'symbol' || typeof value.getMonth === 'function') {
-    return scalar(value, text);
+    return scalar(value, text)
   }
 
-  var ann = asAnnotation(value);
+  var ann = asAnnotation(value)
 
   if (ann) {
-    return updateText(ann, text);
+    return updateText(ann, text)
   }
 
   if (Array.isArray(value)) {
-    // "Circular references" can only exist in objects or arrays
     if (seen.has(value)) {
-      return circularRef(text);
+      return circularRef(text)
     } else {
-      return annotateArray(value, text, seen);
+      return annotateArray(value, text, seen)
     }
   }
 
   if (typeof value === 'object') {
-    // "Circular references" can only exist in objects or arrays
     if (seen.has(value)) {
-      return circularRef(text);
+      return circularRef(text)
     } else {
-      return annotateObject(value, text, seen);
+      return annotateObject(value, text, seen)
     }
   }
 
   if (typeof value === 'function') {
-    return func(text);
+    return func(text)
   }
 
-  return unknown(value, text);
+  return unknown(value, text)
 }
 
 function public_annotate(value, text) {
-  return annotate(value, text, new WeakSet());
+  return annotate(value, text, new WeakSet())
 }
 
 function public_annotateObject(obj, text) {
-  return annotateObject(obj, text, new WeakSet());
-}
+  return annotateObject(obj, text, new WeakSet())
+}