decoders 2.1.0 → 2.2.0-test2

package/annotate.mjs

@@ -1,131 +0,0 @@
-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
-}
-export function object(fields, text) {
-  return brand({
-    type: 'object',
-    fields: fields,
-    text: text,
-  })
-}
-export function array(items, text) {
-  return brand({
-    type: 'array',
-    items: items,
-    text: text,
-  })
-}
-export function func(text) {
-  return brand({
-    type: 'function',
-    text: text,
-  })
-}
-export function unknown(value, text) {
-  return brand({
-    type: 'unknown',
-    value: value,
-    text: text,
-  })
-}
-export function scalar(value, text) {
-  return brand({
-    type: 'scalar',
-    value: value,
-    text: text,
-  })
-}
-export function circularRef(text) {
-  return brand({
-    type: 'circular-ref',
-    text: text,
-  })
-}
-
-export function updateText(annotation, text) {
-  if (text !== undefined) {
-    return brand(
-      _extends({}, annotation, {
-        text: text,
-      })
-    )
-  } else {
-    return annotation
-  }
-}
-
-export function merge(objAnnotation, fields) {
-  var newFields = _extends({}, objAnnotation.fields, fields)
-  return object(newFields, objAnnotation.text)
-}
-export 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())
-}
-export { public_annotate as annotate, public_annotateObject as annotateObject, annotate as __private_annotate }

package/format.js.flow

@@ -1,128 +0,0 @@
-// @flow strict
-
-import { summarize as _summarize, asDate, INDENT, indent, isMultiline } from './_utils';
-import type { Annotation, ArrayAnnotation, ObjectAnnotation } from './annotate';
-
-export type Formatter = (err: Annotation) => string | Error;
-
-function serializeString(s: string, width: number = 80): string {
-    // Full string
-    // Abbreviated to $maxlen i.e. "Vincent Driess..." [truncated]
-    let ser = JSON.stringify(s);
-    if (ser.length <= width) {
-        return ser;
-    }
-
-    // Cut off a bit
-    const truncated = `${s.substring(0, width - 15)}...`;
-    ser = `${JSON.stringify(truncated)} [truncated]`;
-    return ser;
-}
-
-function serializeArray(annotation: ArrayAnnotation, prefix: string): string {
-    const { items } = annotation;
-    if (items.length === 0) {
-        return '[]';
-    }
-
-    const result = [];
-    items.forEach((item) => {
-        const [ser, ann] = serializeAnnotation(item, `${prefix}${INDENT}`);
-        result.push(`${prefix}${INDENT}${ser}${','}`);
-        if (ann !== undefined) {
-            result.push(indent(ann, `${prefix}${INDENT}`));
-        }
-    });
-    return ['[', ...result, `${prefix}]`].join('\n');
-}
-
-function serializeObject(annotation: ObjectAnnotation, prefix: string): string {
-    const { fields } = annotation;
-
-    const fieldNames = Object.keys(fields);
-    if (fieldNames.length === 0) {
-        return '{}';
-    }
-
-    const result = [];
-    fieldNames.forEach((key) => {
-        const valueAnnotation = fields[key];
-        const kser = serializeValue(key);
-
-        const valPrefix = `${prefix}${INDENT}${' '.repeat(kser.length + 2)}`;
-        const [vser, vann] = serializeAnnotation(valueAnnotation, `${prefix}${INDENT}`);
-
-        result.push(`${prefix}${INDENT}${kser}: ${vser},`);
-        if (vann !== undefined) {
-            result.push(indent(vann, valPrefix));
-        }
-    });
-    return ['{', ...result, `${prefix}}`].join('\n');
-}
-
-export function serializeValue(value: mixed): string {
-    // istanbul ignore else
-    if (typeof value === 'string') {
-        return serializeString(value);
-    } else if (typeof value === 'number' || typeof value === 'boolean') {
-        return value.toString();
-    } else if (value === null) {
-        return 'null';
-    } else if (value === undefined) {
-        return 'undefined';
-    } else {
-        const valueAsDate = asDate(value);
-        if (valueAsDate !== null) {
-            return `new Date(${JSON.stringify(valueAsDate.toISOString())})`;
-        } else if (value instanceof Date) {
-            // NOTE: Using `instanceof Date` is unreliable way of checking dates.
-            // If this case occurs (and it didn't pass the prior asDate())
-            // check, then this must be the case where it's an invalid date.
-            return '(Invalid Date)';
-        } else {
-            return '(unserializable)';
-        }
-    }
-}
-
-export function serializeAnnotation(
-    ann: Annotation,
-    prefix: string = '',
-): [string, string | void] {
-    // The serialized data (the input object echoed back)
-    let serialized;
-    if (ann.type === 'array') {
-        serialized = serializeArray(ann, prefix);
-    } else if (ann.type === 'object') {
-        serialized = serializeObject(ann, prefix);
-    } else if (ann.type === 'function') {
-        serialized = '<function>';
-    } else if (ann.type === 'circular-ref') {
-        serialized = '<circular ref>';
-    } else if (ann.type === 'unknown') {
-        serialized = '???';
-    } else {
-        serialized = serializeValue(ann.value);
-    }
-
-    const text = ann.text;
-    if (text !== undefined) {
-        const sep = '^'.repeat(isMultiline(serialized) ? 1 : serialized.length);
-        return [serialized, [sep, text].join(isMultiline(text) ? '\n' : ' ')];
-    } else {
-        return [serialized, undefined];
-    }
-}
-
-export function formatInline(ann: Annotation): string {
-    const [serialized, annotation] = serializeAnnotation(ann);
-    if (annotation !== undefined) {
-        return `${serialized}\n${annotation}`;
-    } else {
-        return serialized;
-    }
-}
-
-export function formatShort(ann: Annotation): string {
-    return _summarize(ann, []).join('\n');
-}

package/format.mjs

@@ -1,110 +0,0 @@
-import { summarize as _summarize, asDate, INDENT, indent, isMultiline } from './_utils.mjs'
-function serializeString(s, width) {
-  if (width === void 0) {
-    width = 80
-  }
-  var ser = JSON.stringify(s)
-  if (ser.length <= width) {
-    return ser
-  }
-  var truncated = s.substring(0, width - 15) + '...'
-  ser = JSON.stringify(truncated) + ' [truncated]'
-  return ser
-}
-function serializeArray(annotation, prefix) {
-  var items = annotation.items
-  if (items.length === 0) {
-    return '[]'
-  }
-  var result = []
-  items.forEach(function (item) {
-    var _serializeAnnotation = serializeAnnotation(item, '' + prefix + INDENT),
-      ser = _serializeAnnotation[0],
-      ann = _serializeAnnotation[1]
-    result.push('' + prefix + INDENT + ser + ',')
-    if (ann !== undefined) {
-      result.push(indent(ann, '' + prefix + INDENT))
-    }
-  })
-  return ['['].concat(result, [prefix + ']']).join('\n')
-}
-function serializeObject(annotation, prefix) {
-  var fields = annotation.fields
-  var fieldNames = Object.keys(fields)
-  if (fieldNames.length === 0) {
-    return '{}'
-  }
-  var result = []
-  fieldNames.forEach(function (key) {
-    var valueAnnotation = fields[key]
-    var kser = serializeValue(key)
-    var valPrefix = '' + prefix + INDENT + ' '.repeat(kser.length + 2)
-    var _serializeAnnotation2 = serializeAnnotation(valueAnnotation, '' + prefix + INDENT),
-      vser = _serializeAnnotation2[0],
-      vann = _serializeAnnotation2[1]
-    result.push('' + prefix + INDENT + kser + ': ' + vser + ',')
-    if (vann !== undefined) {
-      result.push(indent(vann, valPrefix))
-    }
-  })
-  return ['{'].concat(result, [prefix + '}']).join('\n')
-}
-export function serializeValue(value) {
-  if (typeof value === 'string') {
-    return serializeString(value)
-  } else if (typeof value === 'number' || typeof value === 'boolean') {
-    return value.toString()
-  } else if (value === null) {
-    return 'null'
-  } else if (value === undefined) {
-    return 'undefined'
-  } else {
-    var valueAsDate = asDate(value)
-    if (valueAsDate !== null) {
-      return 'new Date(' + JSON.stringify(valueAsDate.toISOString()) + ')'
-    } else if (value instanceof Date) {
-      return '(Invalid Date)'
-    } else {
-      return '(unserializable)'
-    }
-  }
-}
-export function serializeAnnotation(ann, prefix) {
-  if (prefix === void 0) {
-    prefix = ''
-  }
-  var serialized
-  if (ann.type === 'array') {
-    serialized = serializeArray(ann, prefix)
-  } else if (ann.type === 'object') {
-    serialized = serializeObject(ann, prefix)
-  } else if (ann.type === 'function') {
-    serialized = '<function>'
-  } else if (ann.type === 'circular-ref') {
-    serialized = '<circular ref>'
-  } else if (ann.type === 'unknown') {
-    serialized = '???'
-  } else {
-    serialized = serializeValue(ann.value)
-  }
-  var text = ann.text
-  if (text !== undefined) {
-    var sep = '^'.repeat(isMultiline(serialized) ? 1 : serialized.length)
-    return [serialized, [sep, text].join(isMultiline(text) ? '\n' : ' ')]
-  } else {
-    return [serialized, undefined]
-  }
-}
-export function formatInline(ann) {
-  var _serializeAnnotation3 = serializeAnnotation(ann),
-    serialized = _serializeAnnotation3[0],
-    annotation = _serializeAnnotation3[1]
-  if (annotation !== undefined) {
-    return serialized + '\n' + annotation
-  } else {
-    return serialized
-  }
-}
-export function formatShort(ann) {
-  return _summarize(ann, []).join('\n')
-}

package/index.js.flow

@@ -1,44 +0,0 @@
-// @flow strict
-
-export type { Decoder, DecodeResult, DecoderType, Scalar } from './Decoder';
-export type { JSONValue, JSONObject, JSONArray } from './lib/json';
-
-export { define } from './Decoder';
-
-export {
-    always,
-    constant,
-    hardcoded,
-    maybe,
-    mixed,
-    nullable,
-    null_,
-    optional,
-    undefined_,
-    unknown,
-} from './lib/basics';
-export { array, nonEmptyArray, poja, set, tuple } from './lib/arrays';
-export { boolean, numericBoolean, truthy } from './lib/booleans';
-export { date, iso8601 } from './lib/dates';
-export { dict, exact, inexact, mapping, object, pojo } from './lib/objects';
-export { either, oneOf, taggedUnion } from './lib/unions';
-export {
-    email,
-    httpsUrl,
-    nonEmptyString,
-    regex,
-    string,
-    url,
-    uuid,
-    uuidv1,
-    uuidv4,
-} from './lib/strings';
-export { fail, instanceOf, lazy, never, prep } from './lib/utilities';
-export {
-    anyNumber,
-    integer,
-    number,
-    positiveInteger,
-    positiveNumber,
-} from './lib/numbers';
-export { json, jsonObject, jsonArray } from './lib/json';

package/index.mjs

@@ -1,11 +0,0 @@
-export { define } from './Decoder.mjs'
-export { always, constant, hardcoded, maybe, mixed, nullable, null_, optional, undefined_, unknown } from './lib/basics.mjs'
-export { array, nonEmptyArray, poja, set, tuple } from './lib/arrays.mjs'
-export { boolean, numericBoolean, truthy } from './lib/booleans.mjs'
-export { date, iso8601 } from './lib/dates.mjs'
-export { dict, exact, inexact, mapping, object, pojo } from './lib/objects.mjs'
-export { either, oneOf, taggedUnion } from './lib/unions.mjs'
-export { email, httpsUrl, nonEmptyString, regex, string, url, uuid, uuidv1, uuidv4 } from './lib/strings.mjs'
-export { fail, instanceOf, lazy, never, prep } from './lib/utilities.mjs'
-export { anyNumber, integer, number, positiveInteger, positiveNumber } from './lib/numbers.mjs'
-export { json, jsonObject, jsonArray } from './lib/json.mjs'

package/lib/_helpers.d.ts

@@ -1,79 +0,0 @@
-/**
- * Given a type like:
- *
- *   {
- *     a: string;
- *     b: number | undefined;
- *     c: null | undefined;
- *     d: null;
- *     e: undefined;
- *   }
- *
- * Will drop all the "undefined" types. In this case, only "e":
- *
- *   {
- *     a: string;
- *     b: number | undefined;
- *     c: null | undefined;
- *     d: null;
- *   }
- *
- */
-type Compact<T> = { [K in IsDefined<T, keyof T>]: T[K] };
-
-type IsDefined<T, K extends keyof T> = K extends any
-    ? T[K] extends undefined
-        ? never
-        : K
-    : never;
-
-//
-// HACK:
-// These weird conditionals test whether TypeScript is configured with the
-// `strictNullChecks` compiler option. We use these definitions to influence
-// what's considered a "required" vs an "optional" key for the AllowImplicit
-// type.
-//
-// If strictNullChecks is false, then we should not be emitting any `?` fields
-// and consider all fields "required" because everything is optional by default
-// in that mode anyway.
-//
-type NoStrictNullChecks = undefined extends string ? 1 : undefined;
-//                        ^^^^^^^^^^^^^^^^^^^^^^^^
-type StrictNullChecks = undefined extends string ? undefined : 1;
-//                      ^^^^^^^^^^^^^^^^^^^^^^^^
-
-export type RequiredKeys<T> = keyof Compact<{
-    [K in keyof T]: undefined extends T[K] ? NoStrictNullChecks : 1;
-}>;
-
-export type OptionalKeys<T> = keyof Compact<{
-    [K in keyof T]: undefined extends T[K] ? 1 : StrictNullChecks;
-}>;
-
-/**
- * Transforms an object type, by marking all fields that contain "undefined"
- * with a question mark, i.e. allowing implicit-undefineds when
- * explicit-undefined are also allowed.
- *
- * For example, if:
- *
- *   type User = {
- *     name: string;
- *     age: number | null | undefined;
- *   }
- *
- * Then AllowImplicit<User> will become equivalent to:
- *
- *   {
- *     name: string;
- *     age?: number | null;
- *        ^
- *        Note the question mark
- *   }
- */
-type AllowImplicit<T> = { [K in RequiredKeys<T>]-?: T[K] } & {
-    [K in OptionalKeys<T>]+?: Exclude<T[K], undefined>;
-};
-
-export { AllowImplicit };

package/lib/arrays.d.ts

@@ -1,59 +0,0 @@
-/// <reference lib="es6" />
-
-import { Decoder } from '../Decoder';
-
-/**
- * Accepts any array, but doesn't validate its items further.
- *
- * "poja" means "plain old JavaScript array", a play on `pojo()`.
- */
-export const poja: Decoder<unknown[]>;
-
-/**
- * Accepts arrays of whatever the given decoder accepts.
- */
-export function array<T>(decoder: Decoder<T>): Decoder<T[]>;
-
-/**
- * Like `array()`, but will reject arrays with 0 elements.
- */
-export function nonEmptyArray<T>(decoder: Decoder<T>): Decoder<[T, ...T[]]>;
-
-/**
- * Similar to `array()`, but returns the result as an [ES6
- * Set](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set).
- */
-export function set<T>(decoder: Decoder<T>): Decoder<Set<T>>;
-
-/**
- * Accepts a tuple (an array with exactly _n_ items) of values accepted by the
- * _n_ given decoders.
- */
-export function tuple<A>(a: Decoder<A>): Decoder<[A]>;
-export function tuple<A, B>(a: Decoder<A>, b: Decoder<B>): Decoder<[A, B]>;
-export function tuple<A, B, C>(
-    a: Decoder<A>,
-    b: Decoder<B>,
-    c: Decoder<C>,
-): Decoder<[A, B, C]>;
-export function tuple<A, B, C, D>(
-    a: Decoder<A>,
-    b: Decoder<B>,
-    c: Decoder<C>,
-    d: Decoder<D>,
-): Decoder<[A, B, C, D]>;
-export function tuple<A, B, C, D, E>(
-    a: Decoder<A>,
-    b: Decoder<B>,
-    c: Decoder<C>,
-    d: Decoder<D>,
-    e: Decoder<E>,
-): Decoder<[A, B, C, D, E]>;
-export function tuple<A, B, C, D, E, F>(
-    a: Decoder<A>,
-    b: Decoder<B>,
-    c: Decoder<C>,
-    d: Decoder<D>,
-    e: Decoder<E>,
-    f: Decoder<F>,
-): Decoder<[A, B, C, D, E, F]>;

package/lib/arrays.js

@@ -1,85 +0,0 @@
-'use strict'
-
-exports.__esModule = true
-exports.array = array
-exports.nonEmptyArray = nonEmptyArray
-exports.poja = void 0
-exports.set = set
-exports.tuple = void 0
-var _annotate = require('../annotate')
-var _Decoder = require('../Decoder')
-
-var poja = (0, _Decoder.define)(function (blob, ok, err) {
-  if (!Array.isArray(blob)) {
-    return err('Must be an array')
-  }
-  return ok(blob.slice())
-})
-
-exports.poja = poja
-function all(items, blobs, ok, err) {
-  var results = []
-  for (var index = 0; index < items.length; ++index) {
-    var result = items[index]
-    if (result.ok) {
-      results.push(result.value)
-    } else {
-      var ann = result.error
-      var clone = [].concat(blobs)
-      clone.splice(index, 1, (0, _annotate.annotate)(ann, ann.text ? ann.text + ' (at index ' + index + ')' : 'index ' + index))
-      return err((0, _annotate.annotate)(clone))
-    }
-  }
-  return ok(results)
-}
-
-function array(decoder) {
-  return poja.then(function (blobs, ok, err) {
-    var results = blobs.map(decoder.decode)
-    return all(results, blobs, ok, err)
-  })
-}
-
-function nonEmptyArray(decoder) {
-  return array(decoder).refine(function (arr) {
-    return arr.length > 0
-  }, 'Must be non-empty array')
-}
-
-function set(decoder) {
-  return array(decoder).transform(function (items) {
-    return new Set(items)
-  })
-}
-var ntuple = function ntuple(n) {
-  return poja.refine(function (arr) {
-    return arr.length === n
-  }, 'Must be a ' + n + '-tuple')
-}
-
-function _tuple() {
-  for (var _len = arguments.length, decoders = new Array(_len), _key = 0; _key < _len; _key++) {
-    decoders[_key] = arguments[_key]
-  }
-  return ntuple(decoders.length).then(function (blobs, ok, err) {
-    var allOk = true
-    var rvs = decoders.map(function (decoder, i) {
-      var blob = blobs[i]
-      var result = decoder.decode(blob)
-      if (result.ok) {
-        return result.value
-      } else {
-        allOk = false
-        return result.error
-      }
-    })
-    if (allOk) {
-      return ok(rvs)
-    } else {
-      return err((0, _annotate.annotate)(rvs))
-    }
-  })
-}
-
-var tuple = _tuple
-exports.tuple = tuple