decoders 1.25.2 → 1.26.0-beta2

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "decoders",
-    "version": "1.25.2",
+    "version": "1.26.0-beta2",
     "description": "Elegant and battle-tested validation library for type-safe input data (for TypeScript and Flow)",
     "license": "MIT",
     "repository": {
@@ -12,7 +12,8 @@
     "bugs": {
         "url": "https://github.com/nvie/decoders/issues"
     },
-    "main": "./index.js",
+    "main": "./cjs/index.js",
+    "module": "./es/index.js",
     "keywords": [
         "decoder",
         "decoders",
@@ -39,11 +40,14 @@
         "map",
         "predicate"
     ],
+    "peerDependencies": {
+        "@babel/runtime": "^7.16.0"
+    },
     "dependencies": {
-        "debrief": "^1.5.0",
-        "lemons": "^1.4.0"
+        "debrief": "^1.6.0-beta2",
+        "lemons": "^1.7.0-beta2"
     },
-    "types": "./index.d.ts",
+    "types": "./ts/index.d.ts",
     "githubUrl": "https://github.com/nvie/decoders",
     "sideEffects": false
 }

package/{array.d.ts → ts/array.d.ts}

@@ -2,4 +2,4 @@ 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[]>;
+export function nonEmptyArray<T>(decoder: Decoder<T>): Decoder<[T, ...T[]]>;

package/{constants.d.ts → ts/constants.d.ts}

@@ -1,5 +1,4 @@
-import { Decoder } from './types';
-import { Scalar } from './either';
+import { Decoder, Scalar } from './types';
 
 // Constants
 

package/{either.d.ts → ts/either.d.ts}

@@ -1,6 +1,4 @@
-import { Decoder } from './types';
-
-export type Scalar = string | number | boolean | symbol | undefined | null;
+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>;

package/ts/helpers.d.ts

@@ -0,0 +1,79 @@
+/**
+ * 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/{index.d.ts → ts/index.d.ts}

@@ -3,7 +3,7 @@ import { Decoder, DecoderType, Guard, GuardType } from './types';
 export { guard } from './guard';
 export { compose, map, predicate } from './utils';
 
-export { array, poja } from './array';
+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';

package/{object.d.ts → ts/object.d.ts}

@@ -1,9 +1,9 @@
 import { $DecoderType, Decoder } from './types';
 import { AllowImplicit } from './helpers';
 
-export type ObjectDecoderType<T> = AllowImplicit<
-    { [key in keyof T]: $DecoderType<T[key]> }
->;
+export type ObjectDecoderType<T> = AllowImplicit<{
+    [key in keyof T]: $DecoderType<T[key]>;
+}>;
 
 export const pojo: Decoder<{ [key: string]: unknown }>;
 

package/{types.d.ts → ts/types.d.ts}

@@ -1,5 +1,7 @@
 import { Annotation } from 'debrief';
-import Result from 'lemons/Result';
+import { Result } from 'lemons';
+
+export type Scalar = string | number | boolean | symbol | undefined | null;
 
 export interface Guard<T> {
     (blob: unknown): T;

package/helpers.d.ts

@@ -1,62 +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;
-
-export type RequiredKeys<T> = keyof Compact<
-    { [K in keyof T]: undefined extends T[K] ? undefined : 1 }
->;
-
-export type OptionalKeys<T> = keyof Compact<
-    { [K in keyof T]: undefined extends T[K] ? 1 : undefined }
->;
-
-/**
- * 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/types.js

@@ -1,5 +0,0 @@
-"use strict";
-
-var _Result = _interopRequireDefault(require("lemons/Result"));
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }