Added dynamic defaults

src/PseudoPromise.ts

@@ -132,10 +132,8 @@ export class PseudoPromise<ReturnType = undefined> {
           } catch (err) {
             if (err instanceof ZodError) {
               zerr.addIssues(err.issues);
-              console.log(`caught zod error in sync object!`);
               return [k, INVALID] as [string, any];
             }
-            console.log(`throwing nonzod error in sync object!`);
             throw err;
           }
         });

src/__tests__/complex.test.ts

@@ -15,7 +15,6 @@ test('parse', () => {
     numProm: Promise.resolve(12),
     lenfun: (x: string) => x.length,
   });
-  console.log(`SUM: ${value.sumTransformer}`);
   expect(typeof value.sumTransformer).toEqual('number');
 });
 

src/__tests__/pseudopromise.test.ts

@@ -14,7 +14,6 @@ test('sync fail', async () => {
     .then(async () => 15)
     .then(arg => arg.toString())
     .then(arg => {
-      console.log(arg);
       return arg.length;
     });
 

src/__tests__/transformer.test.ts

@@ -59,6 +59,14 @@ test('default', () => {
   expect(data).toEqual('asdf');
 });
 
+test('dynamic default', () => {
+  const data = z
+    .string()
+    .default(s => s._def.t)
+    .parse(undefined); // => "asdf"
+  expect(data).toEqual('string');
+});
+
 test('default when property is null or undefined', () => {
   const data = z
     .object({

src/parser.ts

@@ -128,7 +128,6 @@ export const ZodParser = (schema: z.ZodType<any>) => (
   };
 
   const def: ZodDef = schema._def as any;
-  console.log(`\nPARSING ${def.t}`);
 
   let PROMISE: PseudoPromise<any> = new PseudoPromise();
   (PROMISE as any)._default = true;
@@ -558,12 +557,10 @@ export const ZodParser = (schema: z.ZodType<any>) => (
             return parsedValue;
           } catch (err) {
             if (err instanceof ZodError) {
-              console.log(`caught error at ${key}`);
               const zerr: ZodError = err;
               ERROR.addIssues(zerr.issues);
               return INVALID;
             } else {
-              console.log(`caught non-zod error at ${key}`);
               throw err;
             }
           }
@@ -1048,7 +1045,6 @@ export const ZodParser = (schema: z.ZodType<any>) => (
       // );
       break;
     case z.ZodTypes.transformer:
-      console.log(`TRANSFORMER`);
       PROMISE = new PseudoPromise()
         .then(() => {
           try {
@@ -1062,18 +1058,10 @@ export const ZodParser = (schema: z.ZodType<any>) => (
         })
 
         .then(inputParseResult => {
-          console.log(`inputParseResult`);
-          console.log(inputParseResult);
           // try {
           const transformed = def.transformer(inputParseResult);
           if (transformed instanceof Promise && params.async === false) {
-            console.log(
-              `transformed instanceof Promise && params.async === false`,
-            );
-
-            console.log(`def: ${z.inputSchema(def.output)._def.t}`);
             if (z.inputSchema(def.output)._def.t !== z.ZodTypes.promise) {
-              console.log(`THROWING PROMISE ERROR`);
               throw new Error(
                 "You can't call .parse on a schema containing async transformations.",
               );
@@ -1101,7 +1089,6 @@ export const ZodParser = (schema: z.ZodType<any>) => (
         })
         .catch(err => {
           if (!(err instanceof ZodError)) {
-            console.log(`NON ZOD ERROR`);
             throw err;
           }
           ERROR.addIssues(err.issues);

src/playground.ts

@@ -1,15 +1,11 @@
 import * as z from '.';
-const asyncNumberToString = z.transformer(z.number(), z.string(), async n =>
-  String(n),
-);
+
 const run = async () => {
-  console.log(
-    z
-      .object({
-        id: asyncNumberToString,
-      })
-      .parse({ id: 5 }),
-  );
+  const data = z
+    .string()
+    .default(schema => `${schema._def.t}`)
+    .parse(undefined); // => "string"
+  console.log(data);
 };
 
 run();

src/types/base.ts

@@ -324,16 +324,23 @@ export abstract class ZodType<
     return ZodTransformer.create(this as any, this, input) as any;
   }
 
-  default: <
+  default<
     T extends Output = Output,
     Opt extends ReturnType<this['optional']> = ReturnType<this['optional']>
-  >(
-    def: T,
-  ) => ZodTransformer<Opt, this> = def => {
+  >(def: T): ZodTransformer<Opt, this>;
+  default<
+    T extends (arg: this) => Output,
+    Opt extends ReturnType<this['optional']> = ReturnType<this['optional']>
+  >(def: T): ZodTransformer<Opt, this>;
+  default(def: any) {
     return ZodTransformer.create(this.optional(), this, (x: any) => {
-      return x === undefined ? def : x;
+      return x === undefined
+        ? typeof def === 'function'
+          ? def(this)
+          : def
+        : x;
     }) as any;
-  };
+  }
 
   //  default: (val: Type) => ZodTransformer<ZodType<Type | undefined>, this> = val => {
   //    return ZodTransformer.create(this.optional(), this, x => {