decoders 1.26.0-beta2 → 2.0.0-beta3

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/guard.d.ts

@@ -1,7 +0,0 @@
-import { Decoder, Guard } from './types';
-
-export interface Options {
-    style?: 'inline' | 'simple';
-}
-
-export function guard<T>(decoder: Decoder<T>, options?: Options): Guard<T>;

package/ts/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/ts/index.d.ts

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

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 { $DecoderType, Decoder } 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/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]>;

package/ts/types.d.ts

@@ -1,18 +0,0 @@
-import { Annotation } from 'debrief';
-import { Result } from 'lemons';
-
-export type Scalar = string | number | boolean | symbol | undefined | null;
-
-export interface Guard<T> {
-    (blob: unknown): T;
-}
-export type Predicate<T> = (value: T) => boolean;
-export type DecodeResult<T> = Result<Annotation, T>;
-export interface Decoder<T, F = unknown> {
-    (blob: F): DecodeResult<T>;
-}
-
-export type DecoderType<T> = T extends Decoder<infer V> ? V : never;
-export type $DecoderType<T> = DecoderType<T>; // Alias for backward compatibility
-
-export type GuardType<T> = T extends Guard<infer V> ? V : never;

package/ts/utils.d.ts

@@ -1,13 +0,0 @@
-import { Decoder } from './types';
-
-export function isDate(value: unknown): boolean;
-export function map<T, V>(decoder: Decoder<T>, mapper: (value: T) => V): Decoder<V>;
-export function compose<T, V>(decoder: Decoder<T>, next: Decoder<V, T>): Decoder<V>;
-export function predicate<T extends F, F = unknown>(
-    predicate: (value: F) => value is T,
-    msg: string
-): Decoder<T, F>;
-export function predicate<T>(
-    predicate: (value: T) => boolean,
-    msg: string
-): Decoder<T, T>;