Ts simpler 2

.babelrc.js

@@ -1,19 +1,23 @@
 module.exports = (api) => ({
   presets: [
     [
-      'jason',
+      'babel-preset-jason/esm',
       api.env() !== 'test'
         ? {
             ignoreBrowserslistConfig: true,
-            modules: api.env() === 'modules' ? false : 'commonjs',
+            modules: api.env() === 'esm' ? false : 'commonjs',
           }
         : {
             target: 'node',
+
+            // debug: true,
             targets: { node: 'current' },
           },
     ],
+    '@babel/preset-typescript',
   ],
   plugins: [
+    '@babel/plugin-proposal-logical-assignment-operators',
     api.env() === 'modules' && [
       'transform-rename-import',
       {

.eslintignore

@@ -0,0 +1,2 @@
+.eslintrc
+.eslintrc.js

docs/extending.md

@@ -0,0 +1,103 @@
+# Extending Schema
+
+For simple cases where you want to reuse common schema configurations, creating
+and passing around instances works great and is automatically typed correctly
+
+```js
+import * as yup from 'yup';
+
+const requiredString = yup.string().required().default('');
+
+const momentDate = (parseFormats = ['MMM dd, yyy']) =>
+  yup.date().transform(function (value, originalValue) {
+    if (this.isType(value)) return value;
+
+    // the default coercion transform failed so let's try it with Moment instead
+    value = Moment(originalValue, parseFormats);
+    return value.isValid() ? value.toDate() : yup.date.INVALID_DATE;
+  });
+
+export { momentDate, requiredString };
+```
+
+Schema are immutable so each can be configured further without changing the original.
+
+## Extending Schema with new methods
+
+`yup` provides a `addMethod()` utility for extending built-in schema:
+
+```js
+function parseDateFromFormats(formats, parseStrict) {
+  return this.transform(function (value, originalValue) {
+    if (this.isType(value)) return value;
+
+    value = Moment(originalValue, formats, parseStrict);
+
+    return value.isValid() ? value.toDate() : yup.date.INVALID_DATE;
+  });
+}
+
+yup.addMethod(yup.date, 'format', parseDateFromFormats);
+```
+
+Note that `addMethod` isn't really magic, it mutates the prototype of the passed in schema.
+
+> Note: if you are using TypeScript you also need to adjust the class or interface
+> see the [typescript](./typescript) docs for details.
+
+## Creating new Schema types
+
+If you're use case calls for creating an entirely new type. inheriting from
+and existing schema class may be best: Generally you should not inheriting from
+the abstract `Schema` unless you know what you are doing. The other types are fair game though.
+
+You should keep in mind some basic guidelines when extending schemas:
+
+- never mutate an existing schema, always `clone()` and then mutate the new one before returning it.
+  Built-in methods like `test` and `transform` take care of this for you, so you can safely use them (see below) without worrying
+
+- transforms should never mutate the `value` passed in, and should return an invalid object when one exists
+  (`NaN`, `InvalidDate`, etc) instead of `null` for bad values.
+
+- by the time validations run the `value` is guaranteed to be the correct type, however it still may
+  be `null` or `undefined`
+
+```js
+import { DateSchema } from 'yup';
+
+class MomentDateSchema extends DateSchema {
+  static create() {
+    return MomentDateSchema();
+  }
+
+  constructor() {
+    super();
+    this._validFormats = [];
+
+    this.withMutation(() => {
+      this.transform(function (value, originalvalue) {
+        if (this.isType(value))
+          // we have a valid value
+          return value;
+        return Moment(originalValue, this._validFormats, true);
+      });
+    });
+  }
+
+  _typeCheck(value) {
+    return (
+      super._typeCheck(value) || (moment.isMoment(value) && value.isValid())
+    );
+  }
+
+  format(formats) {
+    if (!formats) throw new Error('must enter a valid format');
+    let next = this.clone();
+    next._validFormats = {}.concat(formats);
+  }
+}
+
+let schema = new MomentDateSchema();
+
+schema.format('YYYY-MM-DD').cast('It is 2012-05-25'); // => Fri May 25 2012 00:00:00 GMT-0400 (Eastern Daylight Time)
+```

docs/typescript.md

@@ -0,0 +1,100 @@
+## TypeScript Support
+
+`yup` comes with robust typescript support! However, because of how dynamic `yup` is
+not everything can be statically typed safely, but for most cases it's "Good Enough".
+
+Not that `yup` schema actually produce _two_ different types: the result of casting an input, and the value after validation.
+Why are these types different? Because a schema can produce a value via casting that
+would not pass validation!
+
+```js
+const schema = string().nullable().required();
+
+schema.cast(null); // -> null
+schema.validateSync(null); // ValidationError this is required!
+```
+
+By itself this seems weird, but has it uses when handling user input. To get a
+TypeScript type that matches all possible `cast()` values, use `yup.TypeOf<typeof schema>`.
+To produce a type that matches a valid object for the schema use `yup.Asserts<typeof schema>>`
+
+```ts
+import * as yup from 'yup';
+
+const personSchema = yup.object({
+  firstName: yup
+    .string()
+    // Here we use `defined` instead of `required` to more closely align with
+    // TypeScript. Both will have the same effect on the resulting type by
+    // excluding `undefined`, but `required` will also disallow empty strings.
+    .defined(),
+  // defaults also affect the possible output type!
+  // schema with default values won't produce `undefined` values. Remember object schema
+  // have a default value built in.
+  nickName: yup.string().default('').nullable(),
+  gender: yup
+    .mixed()
+    // Note `as const`: this types the array as `["male", "female", "other"]`
+    // instead of `string[]`.
+    .oneOf(['male', 'female', 'other'] as const)
+    .defined(),
+  email: yup.string().nullable().notRequired().email(),
+  birthDate: yup.date().nullable().notRequired().min(new Date(1900, 0, 1)),
+});
+```
+
+You can derive the TypeScript type as follows:
+
+```ts
+import type { Asserts, TypeOf } from 'yup';
+
+const parsed: Typeof<typeof personSchema> = personSchema.cast(json);
+
+const validated: Asserts<typeof personSchema> = personSchema.validateSync(
+  parsed,
+);
+```
+
+You can also go the other direction, specifying an interface and ensuring that a schema would match it:
+
+```ts
+import { string, object, number, SchemaOf } from 'yup';
+
+type Person = {
+  firstName: string;
+};
+
+// ✔️ compiles
+const goodPersonSchema: SchemaOf<Person> = object({
+  firstName: string().defined(),
+}).defined();
+
+// ❌ errors:
+// "Type 'number | undefined' is not assignable to type 'string'."
+const badPersonSchema: SchemaOf<Person> = object({
+  firstName: number(),
+});
+```
+
+### TypeScript settings
+
+For type utilties to work correctly with required and nullable types you have
+to set `strict: true` or `strictNullChecks: true` in your tsconfig.json.
+
+### Extending built-in types
+
+You can use TypeScript's interface merging behavior to extend the schema types
+if needed. Type extensions should go in an "ambient" type def file such as your
+`globals.d.ts`.
+
+```ts
+declare module 'yup' {
+  class StringSchema<TIn, TContext, TOut> {
+    myMethod(param: string): this;
+  }
+}
+```
+
+> Watch out!: If your method needs to adjust schema generics, you likely
+> need to also extend the Required*, and Defined* interfaces associated with
+> each basic type. Consult the core types for examples on how to do this

jest-sync.config.json

@@ -6,6 +6,6 @@
   "testEnvironment": "node",
   "setupFilesAfterEnv": ["./test-setup.js"],
   "roots": ["test"],
-  "testRegex": "\\.js",
-  "testPathIgnorePatterns": ["helpers\\.js"]
+  "testRegex": "\\.(t|j)s$",
+  "testPathIgnorePatterns": ["helpers\\.js", "\\.eslintrc\\.js", "types\\.ts"]
 }

package.json

@@ -15,9 +15,7 @@
     "precommit": "lint-staged",
     "toc": "doctoc README.md --github",
     "release": "rollout",
-    "build": "yarn build:commonjs && yarn build:modules && yarn toc",
-    "build:commonjs": "babel src --out-dir lib --delete-dir-on-start",
-    "build:modules": "babel src --out-dir es --delete-dir-on-start --env-name modules",
+    "build": "yarn 4c build && yarn toc",
     "prepublishOnly": "yarn build"
   },
   "files": [
@@ -60,15 +58,22 @@
     "roots": [
       "test"
     ],
-    "testRegex": "\\.js",
+    "testRegex": "\\.(j|t)s$",
     "testPathIgnorePatterns": [
-      "helpers\\.js"
+      "helpers\\.js",
+      "\\.eslintrc\\.js",
+      "types\\.ts"
     ]
   },
   "devDependencies": {
-    "@4c/rollout": "^2.1.10",
+    "@4c/cli": "^2.1.12",
+    "@4c/rollout": "^2.1.11",
+    "@4c/tsconfig": "^0.3.1",
     "@babel/cli": "7.12.1",
     "@babel/core": "7.12.3",
+    "@babel/plugin-proposal-logical-assignment-operators": "^7.12.1",
+    "@babel/preset-typescript": "^7.12.1",
+    "@typescript-eslint/parser": "^4.8.1",
     "babel-core": "^7.0.0-bridge.0",
     "babel-eslint": "^10.1.0",
     "babel-jest": "^26.6.1",
@@ -86,6 +91,8 @@
     "eslint-plugin-jest": "^24.1.0",
     "eslint-plugin-react": "^7.21.5",
     "eslint-plugin-react-hooks": "^4.2.0",
+    "eslint-plugin-ts-expect": "^1.0.1",
+    "eslint-plugin-typescript": "^0.14.0",
     "husky": "^4.3.0",
     "jest": "^26.6.1",
     "lint-staged": "^10.4.2",
@@ -97,12 +104,15 @@
     "rollup-plugin-size-snapshot": "^0.12.0",
     "sinon": "^9.2.0",
     "sinon-chai": "^3.5.0",
-    "synchronous-promise": "^2.0.15"
+    "synchronous-promise": "^2.0.15",
+    "typescript": "^4.0.5"
   },
   "dependencies": {
     "@babel/runtime": "^7.10.5",
+    "@types/lodash": "^4.14.165",
     "lodash": "^4.17.20",
     "lodash-es": "^4.17.11",
+    "nanoclone": "^0.2.1",
     "property-expr": "^2.0.4",
     "toposort": "^2.0.2"
   },

src/Condition.js → src/Condition.ts

@@ -1,8 +1,35 @@
 import has from 'lodash/has';
 import isSchema from './util/isSchema';
+import Reference from './Reference';
+import { SchemaLike } from './types';
 
-class Condition {
-  constructor(refs, options) {
+export interface ConditionBuilder<T extends SchemaLike> {
+  (this: T, value: any, schema: T): SchemaLike;
+  (v1: any, v2: any, schema: T): SchemaLike;
+  (v1: any, v2: any, v3: any, schema: T): SchemaLike;
+  (v1: any, v2: any, v3: any, v4: any, schema: T): SchemaLike;
+}
+
+export type ConditionConfig<T extends SchemaLike> = {
+  is: any | ((...values: any[]) => boolean);
+  then?: SchemaLike | ((schema: T) => SchemaLike);
+  otherwise?: SchemaLike | ((schema: T) => SchemaLike);
+};
+
+export type ConditionOptions<T extends SchemaLike> =
+  | ConditionBuilder<T>
+  | ConditionConfig<T>;
+
+export type ResolveOptions<TContext = any> = {
+  value?: any;
+  parent?: any;
+  context?: TContext;
+};
+
+class Condition<T extends SchemaLike = SchemaLike> {
+  fn: ConditionBuilder<T>;
+
+  constructor(public refs: Reference[], options: ConditionOptions<T>) {
     this.refs = refs;
 
     if (typeof options === 'function') {
@@ -23,9 +50,9 @@ class Condition {
     let check =
       typeof is === 'function'
         ? is
-        : (...values) => values.every((value) => value === is);
+        : (...values: any[]) => values.every((value) => value === is);
 
-    this.fn = function (...args) {
+    this.fn = function (...args: any[]) {
       let options = args.pop();
       let schema = args.pop();
       let branch = check(...args) ? then : otherwise;
@@ -36,7 +63,7 @@ class Condition {
     };
   }
 
-  resolve(base, options) {
+  resolve(base: T, options: ResolveOptions) {
     let values = this.refs.map((ref) =>
       ref.getValue(options?.value, options?.parent, options?.context),
     );