Restore existing type inference behaviour of z.ZodObject

[bentefay]

Fixes the issue documented here: #1121

I'm pretty sure my PR introduced this issue: #1117

In almost all cases z.flatten<{ property: (T | undefined) & T }> flattens to { property: T }. However, this does not appear to be the case for some very specific types like this one:

type Opaque<Type, Token = unknown> = Type & { tag: Token };

  enum FACE {
    QUEEN = "QUEEN",
    KING = "KING",
  }

  enum SUIT {
    HEARTS = "HEARTS",
    DIAMONDS = "DIAMONDS",
  }

  type FaceCard<Face extends FACE> = Opaque<`${Face}_${SUIT}`, "FaceCard">;

  type Hand = z.objectUtil.flatten<
    z.ZodObject<{
      card: z.ZodType<FaceCard<FACE.QUEEN>, z.ZodTypeDef, string>;
    }>["_output"]
  >;

In this case Hand is flattening to:

type Hand = {
    card: (FaceCard<FACE.QUEEN> | undefined) & FaceCard<FACE.QUEEN>;
}

Fortunately, I now better understand the problem I was trying to fix in my PR, and it is actually possible to write z.ZodObject in a way that preserves both behaviours.

It also has the benefit of being easier to understand:

  type optionalKeys<T extends object> = {
    [k in keyof T]: undefined extends T[k] ? k : never;
  }[keyof T];

  type requiredKeys<T extends object> = {
    [k in keyof T]: undefined extends T[k] ? never : k;
  }[keyof T];

  export type addQuestionMarks<T extends object> = Partial<
    Pick<T, optionalKeys<T>>
  > &
    Pick<T, requiredKeys<T>>;

Unfortunately I couldn't see a way to write a test for this, as:

type Hand = {
    card: (FaceCard<FACE.QUEEN> | undefined) & FaceCard<FACE.QUEEN>;
}

and

type Hand = {
    card: FaceCard<FACE.QUEEN>
}

are equal as far as util.AssertEqual is concerned.

[colinhacks]

Sounds good to me. That test may be possible if we switched to using something like https://github.com/dsherret/conditional-type-checks which is a little smarter than the current util.AssertEqual trick, but I've been procrastinating on that. Not vital at the moment.