decoders 1.26.0-beta2 → 2.0.0-beta11

package/_utils.d.ts

@@ -0,0 +1,9 @@
+import { Annotation } from './annotate';
+
+export function asDate(value: unknown): Date | null;
+export function isMultiline(s: string): boolean;
+export function indent(s: string, prefix?: string): string;
+export function summarize(
+    ann: Annotation,
+    keypath?: ReadonlyArray<number | string>,
+): string[];

package/_utils.js

@@ -0,0 +1,102 @@
+"use strict";
+
+exports.__esModule = true;
+exports.INDENT = void 0;
+exports.asDate = asDate;
+exports.indent = indent;
+exports.isMultiline = isMultiline;
+exports.summarize = summarize;
+// $FlowFixMe[unclear-type] - deliberate use of `any`
+// Two spaces of indentation
+var INDENT = '  ';
+/**
+ * Is value is a valid Date instance, then return that. If not, then return
+ * null.
+ */
+
+exports.INDENT = INDENT;
+
+function asDate(value) {
+  //
+  // `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 : null;
+}
+
+function isMultiline(s) {
+  return s.indexOf('\n') >= 0;
+}
+
+function indent(s, prefix) {
+  if (prefix === void 0) {
+    prefix = INDENT;
+  }
+
+  if (isMultiline(s)) {
+    return s.split('\n').map(function (line) {
+      return prefix + line;
+    }).join('\n');
+  } else {
+    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 = [];
+  }
+
+  var result = [];
+
+  if (ann.type === 'array') {
+    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)
+        );
+      });
+    });
+  } else if (ann.type === 'object') {
+    var fields = ann.fields;
+    Object.keys(fields).forEach(function (key) {
+      var value = fields[key];
+      summarize(value, [].concat(keypath, [key])).forEach(function (item) {
+        return (// Collect to results
+          result.push(item)
+        );
+      });
+    });
+  }
+
+  var text = ann.text;
+
+  if (!text) {
+    return result;
+  }
+
+  var prefix;
+
+  if (keypath.length === 0) {
+    prefix = '';
+  } else if (keypath.length === 1) {
+    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('.') + ": ";
+  }
+
+  return [].concat(result, [prefix + text]);
+}

package/_utils.js.flow

@@ -0,0 +1,93 @@
+// @flow strict
+
+import type { Annotation } from './annotate';
+
+// $FlowFixMe[unclear-type] - deliberate use of `any`
+export type _Any = any;
+
+// Two spaces of indentation
+export const INDENT = '  ';
+
+/**
+ * Is value is a valid Date instance, then return that. If not, then return
+ * null.
+ */
+export function asDate(value: mixed): 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 {
+    return s.indexOf('\n') >= 0;
+}
+
+export function indent(s: string, prefix: string = INDENT): string {
+    if (isMultiline(s)) {
+        return s
+            .split('\n')
+            .map((line) => prefix + line)
+            .join('\n');
+    } else {
+        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: Annotation,
+    keypath: $ReadOnlyArray<number | string> = [],
+): Array<string> {
+    const result: Array<string> = [];
+
+    if (ann.type === 'array') {
+        const items = ann.items;
+        let index = 0;
+        items.forEach((ann) => {
+            summarize(ann, [...keypath, index++]).forEach((item) =>
+                // Collect to results
+                result.push(item),
+            );
+        });
+    } else if (ann.type === 'object') {
+        const fields = ann.fields;
+        Object.keys(fields).forEach((key) => {
+            const value = fields[key];
+            summarize(value, [...keypath, key]).forEach((item) =>
+                // Collect to results
+                result.push(item),
+            );
+        });
+    }
+
+    const text = ann.text;
+    if (!text) {
+        return result;
+    }
+
+    let prefix: string;
+    if (keypath.length === 0) {
+        prefix = '';
+    } else if (keypath.length === 1) {
+        prefix =
+            typeof keypath[0] === 'number'
+                ? `Value at index ${keypath[0]}: `
+                : `Value at key ${JSON.stringify(keypath[0])}: `;
+    } else {
+        prefix = `Value at keypath ${keypath.map((x) => x.toString()).join('.')}: `;
+    }
+    return [...result, prefix + text];
+}

package/_utils.mjs

@@ -0,0 +1,89 @@
+// $FlowFixMe[unclear-type] - deliberate use of `any`
+// Two spaces of indentation
+export var INDENT = '  ';
+/**
+ * Is value is a valid Date instance, then return that. If not, then return
+ * null.
+ */
+
+export function asDate(value) {
+  //
+  // `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 : null;
+}
+export function isMultiline(s) {
+  return s.indexOf('\n') >= 0;
+}
+export function indent(s, prefix) {
+  if (prefix === void 0) {
+    prefix = INDENT;
+  }
+
+  if (isMultiline(s)) {
+    return s.split('\n').map(function (line) {
+      return prefix + line;
+    }).join('\n');
+  } else {
+    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 = [];
+  }
+
+  var result = [];
+
+  if (ann.type === 'array') {
+    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)
+        );
+      });
+    });
+  } else if (ann.type === 'object') {
+    var fields = ann.fields;
+    Object.keys(fields).forEach(function (key) {
+      var value = fields[key];
+      summarize(value, [].concat(keypath, [key])).forEach(function (item) {
+        return (// Collect to results
+          result.push(item)
+        );
+      });
+    });
+  }
+
+  var text = ann.text;
+
+  if (!text) {
+    return result;
+  }
+
+  var prefix;
+
+  if (keypath.length === 0) {
+    prefix = '';
+  } else if (keypath.length === 1) {
+    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('.') + ": ";
+  }
+
+  return [].concat(result, [prefix + text]);
+}

package/annotate.d.ts

@@ -0,0 +1,62 @@
+export interface ObjectAnnotation {
+    readonly type: 'object';
+    readonly fields: { readonly [key: string]: Annotation };
+    readonly text?: string;
+}
+
+export interface ArrayAnnotation {
+    readonly type: 'array';
+    readonly items: readonly Annotation[];
+    readonly text?: string;
+}
+
+export interface ScalarAnnotation {
+    readonly type: 'scalar';
+    readonly value: unknown;
+    readonly text?: string;
+}
+
+export interface FunctionAnnotation {
+    readonly type: 'function';
+    readonly text?: string;
+}
+
+export interface CircularRefAnnotation {
+    readonly type: 'circular-ref';
+    readonly text?: string;
+}
+
+export interface UnknownAnnotation {
+    readonly type: 'unknown';
+    readonly value: unknown;
+    readonly text?: string;
+}
+
+export type Annotation =
+    | ObjectAnnotation
+    | ArrayAnnotation
+    | ScalarAnnotation
+    | FunctionAnnotation
+    | CircularRefAnnotation
+    | UnknownAnnotation;
+
+export function object(
+    fields: { readonly [key: string]: Annotation },
+    text?: string,
+): ObjectAnnotation;
+export function array(items: readonly Annotation[], text?: string): ArrayAnnotation;
+export function func(text?: string): FunctionAnnotation;
+export function unknown(value: unknown, text?: string): UnknownAnnotation;
+export function scalar(value: unknown, text?: string): ScalarAnnotation;
+export function circularRef(text?: string): CircularRefAnnotation;
+export function updateText<A extends Annotation>(annotation: A, text?: string): A;
+export function merge(
+    objAnnotation: ObjectAnnotation,
+    fields: { readonly [key: string]: Annotation },
+): ObjectAnnotation;
+export function asAnnotation(thing: unknown): Annotation | void;
+export function annotate(value: unknown, text?: string): Annotation;
+export function annotateObject(
+    obj: { readonly [field: string]: unknown },
+    text?: string,
+): ObjectAnnotation;

package/annotate.js

@@ -0,0 +1,161 @@
+"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();
+
+function brand(ann) {
+  _register.add(ann);
+
+  return ann;
+}
+
+function object(fields, text) {
+  return brand({
+    type: 'object',
+    fields: fields,
+    text: text
+  });
+}
+
+function array(items, text) {
+  return brand({
+    type: 'array',
+    items: items,
+    text: text
+  });
+}
+
+function func(text) {
+  return brand({
+    type: 'function',
+    text: text
+  });
+}
+
+function unknown(value, text) {
+  return brand({
+    type: 'unknown',
+    value: value,
+    text: text
+  });
+}
+
+function scalar(value, text) {
+  return brand({
+    type: 'scalar',
+    value: value,
+    text: text
+  });
+}
+
+function circularRef(text) {
+  return brand({
+    type: 'circular-ref',
+    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
+    }));
+  } else {
+    return annotation;
+  }
+}
+/**
+ * Given an existing ObjectAnnotation, merges new Annotations in there.
+ */
+
+
+function merge(objAnnotation, fields) {
+  var newFields = _extends({}, objAnnotation.fields, fields);
+
+  return object(newFields, objAnnotation.text);
+}
+
+function asAnnotation(thing) {
+  return typeof thing === 'object' && thing !== null && _register.has(thing) ? thing : undefined;
+}
+
+function annotateArray(value, text, seen) {
+  seen.add(value);
+  var items = value.map(function (v) {
+    return annotate(v, undefined, seen);
+  });
+  return array(items, text);
+}
+
+function annotateObject(obj, text, seen) {
+  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);
+}
+
+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);
+  }
+
+  var ann = asAnnotation(value);
+
+  if (ann) {
+    return updateText(ann, text);
+  }
+
+  if (Array.isArray(value)) {
+    // "Circular references" can only exist in objects or arrays
+    if (seen.has(value)) {
+      return circularRef(text);
+    } else {
+      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);
+    } else {
+      return annotateObject(value, text, seen);
+    }
+  }
+
+  if (typeof value === 'function') {
+    return func(text);
+  }
+
+  return unknown(value, text);
+}
+
+function public_annotate(value, text) {
+  return annotate(value, text, new WeakSet());
+}
+
+function public_annotateObject(obj, text) {
+  return annotateObject(obj, text, new WeakSet());
+}