decoders 2.0.0-beta1 → 2.0.0-beta2

package/ts/annotate.d.ts

@@ -1,58 +0,0 @@
-export interface ObjectAnnotation {
-    type: 'object';
-    fields: { [key: string]: Annotation };
-    text?: string;
-}
-
-export interface ArrayAnnotation {
-    type: 'array';
-    items: readonly Annotation[];
-    text?: string;
-}
-
-export interface ScalarAnnotation {
-    type: 'scalar';
-    value: unknown;
-    text?: string;
-}
-
-export interface FunctionAnnotation {
-    type: 'function';
-    text?: string;
-}
-
-export interface CircularRefAnnotation {
-    type: 'circular-ref';
-    text?: string;
-}
-
-export type Annotation =
-    | ObjectAnnotation
-    | ArrayAnnotation
-    | ScalarAnnotation
-    | FunctionAnnotation
-    | CircularRefAnnotation;
-
-export function object(
-    fields: { [key: string]: Annotation },
-    text?: string,
-): ObjectAnnotation;
-export function array(items: readonly Annotation[], text?: string): ArrayAnnotation;
-export function func(text?: string): FunctionAnnotation;
-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: { [key: string]: Annotation },
-): ObjectAnnotation;
-
-export function asAnnotation(thing: unknown): Annotation | void;
-
-export function annotate(value: unknown, text?: string): Annotation;
-export function annotateObject(
-    obj: { [key: string]: unknown },
-    text?: string,
-): ObjectAnnotation;

package/ts/array.d.ts

@@ -1,5 +0,0 @@
-import { Decoder } from '../_types';
-
-export const poja: Decoder<unknown[]>;
-export function array<T>(decoder: Decoder<T>): Decoder<T[]>;
-export function nonEmptyArray<T>(decoder: Decoder<T>): Decoder<[T, ...T[]]>;

package/ts/boolean.d.ts

@@ -1,5 +0,0 @@
-import { Decoder } from '../_types';
-
-export const boolean: Decoder<boolean>;
-export const truthy: Decoder<boolean>;
-export const numericBoolean: Decoder<boolean>;

package/ts/constants.d.ts

@@ -1,11 +0,0 @@
-import { Decoder, Scalar } from '../_types';
-
-// Constants
-
-export const null_: Decoder<null>;
-export const undefined_: Decoder<undefined>;
-export function constant<T extends Scalar>(value: T): Decoder<T>;
-export function hardcoded<T extends Scalar>(value: T): Decoder<T>;
-export function hardcoded<T>(value: T): Decoder<T>;
-export const mixed: Decoder<unknown>;
-export const unknown: Decoder<unknown>;

package/ts/date.d.ts

@@ -1,4 +0,0 @@
-import { Decoder } from '../_types';
-
-export const date: Decoder<Date>;
-export const iso8601: Decoder<Date>;

package/ts/describe.d.ts

@@ -1,3 +0,0 @@
-import { Decoder } from '../_types';
-
-export function describe<T>(decoder: Decoder<T>, msg: string): Decoder<T>;

package/ts/dispatch.d.ts

@@ -1,8 +0,0 @@
-import { Decoder, DecoderType } from '../_types';
-
-export type $Values<T extends object> = T[keyof T];
-
-export function dispatch<O extends { [key: string]: Decoder<any> }>(
-    field: string,
-    mapping: O,
-): Decoder<$Values<{ [key in keyof O]: DecoderType<O[key]> }>>;

package/ts/either.d.ts

@@ -1,61 +0,0 @@
-import { Decoder, Scalar } from '../_types';
-
-export function either<T1, T2>(d1: Decoder<T1>, d2: Decoder<T2>): Decoder<T1 | T2>;
-export function either2<T1, T2>(d1: Decoder<T1>, d2: Decoder<T2>): Decoder<T1 | T2>;
-export function either3<T1, T2, T3>(
-    d1: Decoder<T1>,
-    d2: Decoder<T2>,
-    d3: Decoder<T3>,
-): Decoder<T1 | T2 | T3>;
-export function either4<T1, T2, T3, T4>(
-    d1: Decoder<T1>,
-    d2: Decoder<T2>,
-    d3: Decoder<T3>,
-    d4: Decoder<T4>,
-): Decoder<T1 | T2 | T3 | T4>;
-export function either5<T1, T2, T3, T4, T5>(
-    d1: Decoder<T1>,
-    d2: Decoder<T2>,
-    d3: Decoder<T3>,
-    d4: Decoder<T4>,
-    d5: Decoder<T5>,
-): Decoder<T1 | T2 | T3 | T4 | T5>;
-export function either6<T1, T2, T3, T4, T5, T6>(
-    d1: Decoder<T1>,
-    d2: Decoder<T2>,
-    d3: Decoder<T3>,
-    d4: Decoder<T4>,
-    d5: Decoder<T5>,
-    d6: Decoder<T6>,
-): Decoder<T1 | T2 | T3 | T4 | T5 | T6>;
-export function either7<T1, T2, T3, T4, T5, T6, T7>(
-    d1: Decoder<T1>,
-    d2: Decoder<T2>,
-    d3: Decoder<T3>,
-    d4: Decoder<T4>,
-    d5: Decoder<T5>,
-    d6: Decoder<T6>,
-    d7: Decoder<T7>,
-): Decoder<T1 | T2 | T3 | T4 | T5 | T6 | T7>;
-export function either8<T1, T2, T3, T4, T5, T6, T7, T8>(
-    d1: Decoder<T1>,
-    d2: Decoder<T2>,
-    d3: Decoder<T3>,
-    d4: Decoder<T4>,
-    d5: Decoder<T5>,
-    d6: Decoder<T6>,
-    d7: Decoder<T7>,
-    d8: Decoder<T8>,
-): Decoder<T1 | T2 | T3 | T4 | T5 | T6 | T7 | T8>;
-export function either9<T1, T2, T3, T4, T5, T6, T7, T8, T9>(
-    d1: Decoder<T1>,
-    d2: Decoder<T2>,
-    d3: Decoder<T3>,
-    d4: Decoder<T4>,
-    d5: Decoder<T5>,
-    d6: Decoder<T6>,
-    d7: Decoder<T7>,
-    d8: Decoder<T8>,
-    d9: Decoder<T9>,
-): Decoder<T1 | T2 | T3 | T4 | T5 | T6 | T7 | T8 | T9>;
-export function oneOf<T extends Scalar>(constants: readonly T[]): Decoder<T>;

package/ts/fail.d.ts

@@ -1,3 +0,0 @@
-import { Decoder } from '../_types';
-
-export function fail(msg: string): Decoder<never>;

package/ts/index.d.ts

@@ -1,42 +0,0 @@
-export { Decoder, Guard } from './_types';
-export { DecoderType, GuardType } from './_types';
-
-export { guard } from './_guard';
-export { compose, map, predicate } from './_utils';
-
-export { JSONArray, JSONObject, JSONValue } from './stdlib/json';
-
-export { array, nonEmptyArray, poja } from './stdlib/array';
-export { boolean, numericBoolean, truthy } from './stdlib/boolean';
-export {
-    constant,
-    hardcoded,
-    mixed,
-    null_,
-    undefined_,
-    unknown,
-} from './stdlib/constants';
-export { date, iso8601 } from './stdlib/date';
-export { describe } from './stdlib/describe';
-export { dispatch } from './stdlib/dispatch';
-export {
-    either,
-    either3,
-    either4,
-    either5,
-    either6,
-    either7,
-    either8,
-    either9,
-    oneOf,
-} from './stdlib/either';
-export { fail } from './stdlib/fail';
-export { instanceOf } from './stdlib/instanceOf';
-export { json, jsonArray, jsonObject } from './stdlib/json';
-export { lazy } from './stdlib/lazy';
-export { mapping, dict } from './stdlib/mapping';
-export { integer, number, positiveInteger, positiveNumber } from './stdlib/number';
-export { exact, inexact, object, pojo } from './stdlib/object';
-export { maybe, nullable, optional } from './stdlib/optional';
-export { email, nonEmptyString, regex, string, url } from './stdlib/string';
-export { tuple1, tuple2, tuple3, tuple4, tuple5, tuple6 } from './stdlib/tuple';

package/ts/inline.d.ts

@@ -1,3 +0,0 @@
-import { Annotation } from '../annotate';
-
-export function formatInline(ann: Annotation): string;

package/ts/instanceOf.d.ts

@@ -1,3 +0,0 @@
-import { Decoder } from '../_types';
-
-export function instanceOf<T>(klass: new (...args: any) => T): Decoder<T>;

package/ts/json.d.ts

@@ -1,11 +0,0 @@
-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/ts/lazy.d.ts

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

package/ts/mapping.d.ts

@@ -1,4 +0,0 @@
-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/ts/number.d.ts

@@ -1,6 +0,0 @@
-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/ts/object.d.ts

@@ -1,33 +0,0 @@
-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/ts/optional.d.ts

@@ -1,5 +0,0 @@
-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/ts/result.d.ts

@@ -1,39 +0,0 @@
-export interface Ok<T> {
-    readonly type: 'ok';
-    readonly value: T;
-}
-
-export interface Err<E> {
-    readonly type: 'err';
-    readonly error: E;
-}
-
-export type Result<T, E> = Ok<T> | Err<E>;
-
-export function ok<T>(value: T): Ok<T>;
-export function err<E>(error: E): Err<E>;
-export function toString(result: Result<unknown, unknown>): string;
-export function isOk(result: Result<unknown, unknown>): boolean;
-export function isErr(result: Result<unknown, unknown>): boolean;
-export function withDefault<T>(result: Result<T, unknown>, defaultValue: T): T;
-export function value<T>(result: Result<T, unknown>): void | T;
-export function errValue<E>(result: Result<unknown, E>): void | E;
-export function unwrap<T>(result: Result<T, unknown>): T;
-export function expect<T>(result: Result<T, unknown>, message: string | Error): T;
-export function dispatch<T, E, O>(
-    result: Result<T, E>,
-    okCallback: (value: T) => O,
-    errCallback: (error: E) => O,
-): O;
-export function andThen<T, E, V>(
-    result: Result<T, E>,
-    callback: (value: T) => Result<V, E>,
-): Result<V, E>;
-export function map<T, E, T2>(
-    result: Result<T, E>,
-    mapper: (value: T) => T2,
-): Result<T2, E>;
-export function mapError<T, E, E2>(
-    result: Result<T, E>,
-    mapper: (error: E) => E2,
-): Result<T, E2>;

package/ts/short.d.ts

@@ -1,3 +0,0 @@
-import { Annotation } from '../annotate';
-
-export function formatShort(ann: Annotation): string;

package/ts/string.d.ts

@@ -1,7 +0,0 @@
-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/ts/tuple.d.ts

@@ -1,30 +0,0 @@
-import { Decoder } from '../_types';
-
-export function tuple1<T1>(d1: Decoder<T1>): Decoder<[T1]>;
-export function tuple2<T1, T2>(d1: Decoder<T1>, d2: Decoder<T2>): Decoder<[T1, T2]>;
-export function tuple3<T1, T2, T3>(
-    d1: Decoder<T1>,
-    d2: Decoder<T2>,
-    d3: Decoder<T3>,
-): Decoder<[T1, T2, T3]>;
-export function tuple4<T1, T2, T3, T4>(
-    d1: Decoder<T1>,
-    d2: Decoder<T2>,
-    d3: Decoder<T3>,
-    d4: Decoder<T4>,
-): Decoder<[T1, T2, T3, T4]>;
-export function tuple5<T1, T2, T3, T4, T5>(
-    d1: Decoder<T1>,
-    d2: Decoder<T2>,
-    d3: Decoder<T3>,
-    d4: Decoder<T4>,
-    d5: Decoder<T5>,
-): Decoder<[T1, T2, T3, T4, T5]>;
-export function tuple6<T1, T2, T3, T4, T5, T6>(
-    d1: Decoder<T1>,
-    d2: Decoder<T2>,
-    d3: Decoder<T3>,
-    d4: Decoder<T4>,
-    d5: Decoder<T5>,
-    d6: Decoder<T6>,
-): Decoder<[T1, T2, T3, T4, T5, T6]>;