decoders 2.1.0 → 2.2.0-test2

package/_utils.js.flow

@@ -1,107 +0,0 @@
-// @flow strict
-
-import type { Annotation } from './annotate';
-import type { Scalar } from './Decoder';
-
-// $FlowFixMe[unclear-type] - deliberate use of `any`
-export type _Any = any;
-
-// Two spaces of indentation
-export const INDENT = '  ';
-
-/**
- * Subtract two sets. Why isn't this a standard method on Sets?
- */
-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
- * 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(String).join('.')}: `;
-    }
-    return [...result, `${prefix}${text}`];
-}

package/_utils.mjs

@@ -1,70 +0,0 @@
-export var INDENT = '  '
-
-export function subtract(xs, ys) {
-  var result = new Set()
-  xs.forEach(function (x) {
-    if (!ys.has(x)) {
-      result.add(x)
-    }
-  })
-  return result
-}
-
-export function asDate(value) {
-  return !!value && 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
-  }
-}
-
-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 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 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(String).join('.') + ': '
-  }
-  return [].concat(result, ['' + prefix + text])
-}

package/annotate.d.ts

@@ -1,62 +0,0 @@
-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

@@ -1,145 +0,0 @@
-'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)
-  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,
-  })
-}
-
-function updateText(annotation, text) {
-  if (text !== undefined) {
-    return brand(
-      _extends({}, annotation, {
-        text: text,
-      })
-    )
-  } else {
-    return annotation
-  }
-}
-
-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)) {
-    if (seen.has(value)) {
-      return circularRef(text)
-    } else {
-      return annotateArray(value, text, seen)
-    }
-  }
-  if (typeof value === 'object') {
-    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())
-}

package/annotate.js.flow

@@ -1,218 +0,0 @@
-// @flow strict
-
-type cast = $FlowFixMe;
-
-const _register: WeakSet<{ ... }> = new WeakSet();
-
-export type ObjectAnnotation = {|
-    +type: 'object',
-    +fields: { +[key: string]: Annotation },
-    +text?: string,
-|};
-
-export type ArrayAnnotation = {|
-    +type: 'array',
-    +items: $ReadOnlyArray<Annotation>,
-    +text?: string,
-|};
-
-export type ScalarAnnotation = {|
-    +type: 'scalar',
-    +value: mixed,
-    +text?: string,
-|};
-
-export type FunctionAnnotation = {|
-    +type: 'function',
-    +text?: string,
-|};
-
-export type CircularRefAnnotation = {|
-    +type: 'circular-ref',
-    +text?: string,
-|};
-
-export type UnknownAnnotation = {|
-    +type: 'unknown',
-    +value: mixed,
-    +text?: string,
-|};
-
-export type Annotation =
-    | ObjectAnnotation
-    | ArrayAnnotation
-    | ScalarAnnotation
-    | FunctionAnnotation
-    | CircularRefAnnotation
-    | UnknownAnnotation;
-
-function brand<A: Annotation>(ann: A): A {
-    _register.add(ann);
-    return ann;
-}
-
-export function object(
-    fields: { +[key: string]: Annotation },
-    text?: string,
-): ObjectAnnotation {
-    return brand({ type: 'object', fields, text });
-}
-
-export function array(items: $ReadOnlyArray<Annotation>, text?: string): ArrayAnnotation {
-    return brand({
-        type: 'array',
-        items,
-        text,
-    });
-}
-
-export function func(text?: string): FunctionAnnotation {
-    return brand({
-        type: 'function',
-        text,
-    });
-}
-
-export function unknown(value: mixed, text?: string): UnknownAnnotation {
-    return brand({
-        type: 'unknown',
-        value,
-        text,
-    });
-}
-
-export function scalar(value: mixed, text?: string): ScalarAnnotation {
-    return brand({
-        type: 'scalar',
-        value,
-        text,
-    });
-}
-
-export function circularRef(text?: string): CircularRefAnnotation {
-    return brand({
-        type: 'circular-ref',
-        text,
-    });
-}
-
-/**
- * Given an existing Annotation, set the annotation's text to a new value.
- */
-export function updateText<A: Annotation>(annotation: A, text?: string): A {
-    if (text !== undefined) {
-        return brand({ ...annotation, text });
-    } else {
-        return annotation;
-    }
-}
-
-/**
- * Given an existing ObjectAnnotation, merges new Annotations in there.
- */
-export function merge(
-    objAnnotation: ObjectAnnotation,
-    fields: { +[key: string]: Annotation },
-): ObjectAnnotation {
-    const newFields = { ...objAnnotation.fields, ...fields };
-    return object(newFields, objAnnotation.text);
-}
-
-export function asAnnotation(thing: mixed): Annotation | void {
-    return typeof thing === 'object' && thing !== null && _register.has(thing)
-        ? ((thing: cast): Annotation)
-        : undefined;
-}
-
-type RefSet = WeakSet<{ ... } | $ReadOnlyArray<mixed>>;
-
-function annotateArray(
-    value: $ReadOnlyArray<mixed>,
-    text?: string,
-    seen: RefSet,
-): ArrayAnnotation | CircularRefAnnotation {
-    seen.add(value);
-
-    const items = value.map((v) => annotate(v, undefined, seen));
-    return array(items, text);
-}
-
-function annotateObject(
-    obj: { +[string]: mixed },
-    text?: string,
-    seen: RefSet,
-): ObjectAnnotation {
-    seen.add(obj);
-
-    const fields = {};
-    Object.keys(obj).forEach((key) => {
-        const value = obj[key];
-        fields[key] = annotate(value, undefined, seen);
-    });
-    return object(fields, text);
-}
-
-function annotate(value: mixed, text?: string, seen: RefSet): Annotation {
-    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);
-    }
-
-    const 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: mixed, text?: string): Annotation {
-    return annotate(value, text, new WeakSet());
-}
-
-function public_annotateObject(
-    obj: { +[string]: mixed },
-    text?: string,
-): ObjectAnnotation {
-    return annotateObject(obj, text, new WeakSet());
-}
-
-export {
-    // This construct just ensures the "seen" weakmap (used for circular
-    // reference detection) isn't made part of the public API.
-    public_annotate as annotate,
-    public_annotateObject as annotateObject,
-    //
-    // NOTE: Don't acces theses private APIs directly. They are only exported here
-    // to better enable unit testing.
-    annotate as __private_annotate,
-};