type fixes for zod v4 (#6604)

## 📝 Summary

<!--
Provide a concise summary of what this pull request is addressing.

If this PR fixes any issues, list them here by number (e.g., Fixes
#123).
-->

PR Looks good, just small type fixes.

## 🔍 Description of Changes

<!--
Detail the specific changes made in this pull request. Explain the
problem addressed and how it was resolved. If applicable, provide before
and after comparisons, screenshots, or any relevant details to help
reviewers understand the changes easily.
-->

## 📋 Checklist

- [x] I have read the [contributor
guidelines](https://github.com/marimo-team/marimo/blob/main/CONTRIBUTING.md).
- [ ] For large changes, or changes that affect the public API: this
change was discussed or approved through an issue, on
[Discord](https://marimo.io/discord?ref=pr), or the community
[discussions](https://github.com/marimo-team/marimo/discussions) (Please
provide a link if applicable).
- [ ] I have added tests for the changes made.
- [x] I have run the code and verified that it works as expected.

Author: Light2Dark

frontend/src/components/forms/form-utils.ts

@@ -4,11 +4,9 @@ import { z } from "zod";
 import { Logger } from "@/utils/Logger";
 import { isZodArray, isZodPipe, isZodTuple } from "@/utils/zod-utils";
 
-export function maybeUnwrap<T extends z.ZodType<unknown>>(
-  schema: T,
-): z.ZodType<unknown> {
+export function maybeUnwrap<T extends z.ZodType>(schema: T): z.ZodType {
   if ("unwrap" in schema) {
-    return (schema as unknown as z.ZodOptional).unwrap() as z.ZodType<unknown>;
+    return (schema as unknown as z.ZodOptional).unwrap() as z.ZodType;
   }
   return schema;
 }
@@ -76,18 +74,16 @@ export function getDefaults<TSchema extends z.ZodType<T>, T>(
   }
 
   return Object.fromEntries(
-    Object.entries(schema.shape).map(
-      ([key, value]: [string, z.ZodType<unknown>]) => {
-        return [key, getDefaultValue(value)];
-      },
-    ),
+    Object.entries(schema.shape).map(([key, value]: [string, z.ZodType]) => {
+      return [key, getDefaultValue(value)];
+    }),
   ) as T;
 }
 
 /**
  * Get the literal value of a union
  */
-export function getUnionLiteral<T extends z.ZodType<unknown>>(
+export function getUnionLiteral<T extends z.ZodType>(
   schema: T,
 ): z.ZodLiteral<string> {
   if (schema instanceof z.ZodLiteral) {

frontend/src/components/forms/form.tsx

@@ -27,6 +27,7 @@ import {
 import { cn } from "@/utils/cn";
 import { Events } from "@/utils/events";
 import { Strings } from "@/utils/strings";
+import { isZodPipe } from "@/utils/zod-utils";
 import { Objects } from "../../utils/objects";
 import { Button } from "../ui/button";
 import { Checkbox } from "../ui/checkbox";
@@ -101,7 +102,7 @@ export function renderZodSchema<T extends FieldValues, S>(
   } = FieldOptions.parse(schema.description || "");
 
   if (schema instanceof z.ZodDefault) {
-    let inner = schema.unwrap() as z.ZodType<unknown>;
+    let inner = schema.unwrap() as z.ZodType;
     inner =
       !inner.description && schema.description
         ? inner.describe(schema.description)
@@ -110,7 +111,7 @@ export function renderZodSchema<T extends FieldValues, S>(
   }
 
   if (schema instanceof z.ZodOptional) {
-    let inner = schema.unwrap() as z.ZodType<unknown>;
+    let inner = schema.unwrap() as z.ZodType;
     inner =
       !inner.description && schema.description
         ? inner.describe(schema.description)
@@ -134,7 +135,7 @@ export function renderZodSchema<T extends FieldValues, S>(
         {Objects.entries(schema.shape).map(([key, value]) => {
           const isLiteral = value instanceof z.ZodLiteral;
           const childForm = renderZodSchema(
-            value as z.ZodType<unknown>,
+            value as z.ZodType,
             form,
             joinPath(path, key),
             renderers,
@@ -322,7 +323,7 @@ export function renderZodSchema<T extends FieldValues, S>(
       <div className="flex flex-col gap-1">
         <Label>{label}</Label>
         <FormArray
-          schema={schema.element as z.ZodType<unknown>}
+          schema={schema.element as z.ZodType}
           form={form}
           path={path}
           key={path}
@@ -335,7 +336,7 @@ export function renderZodSchema<T extends FieldValues, S>(
 
   if (schema instanceof z.ZodDiscriminatedUnion) {
     const def = schema.def;
-    const options = def.options as z.ZodType<unknown>[];
+    const options = def.options as z.ZodType[];
     const discriminator = def.discriminator;
     const getSchemaValue = (value: string) => {
       return options.find((option) => {
@@ -402,7 +403,7 @@ export function renderZodSchema<T extends FieldValues, S>(
         control={form.control}
         name={path}
         render={({ field }) => {
-          const options = schema.options as z.ZodType<unknown>[];
+          const options = schema.options as z.ZodType[];
           let value: string = field.value;
           const types = options.map((option) => {
             return getUnionLiteral(option).value;
@@ -460,13 +461,8 @@ export function renderZodSchema<T extends FieldValues, S>(
     // Handle ZodEffects (transforms/refinements)
     return renderZodSchema(maybeUnwrap(schema), form, path, renderers);
   }
-  if (schema instanceof z.ZodPipe) {
-    return renderZodSchema(
-      schema.in as z.ZodType<unknown>,
-      form,
-      path,
-      renderers,
-    );
+  if (isZodPipe(schema)) {
+    return renderZodSchema(schema.in, form, path, renderers);
   }
 
   return (
@@ -487,7 +483,7 @@ const FormArray = ({
   minLength,
   renderers,
 }: {
-  schema: z.ZodType<unknown>;
+  schema: z.ZodType;
   form: UseFormReturn<any>;
   path: Path<any>;
   renderers: FormRenderer[];

frontend/src/core/config/config-schema.ts

@@ -291,7 +291,7 @@ export function parseConfigOverrides(config: unknown): {} {
 }
 
 export function defaultUserConfig(): UserConfig {
-  return UserConfigSchema.parse({
+  const defaultConfig: Partial<Record<keyof UserConfig, unknown>> = {
     completion: {},
     save: {},
     formatting: {},
@@ -302,5 +302,6 @@ export function defaultUserConfig(): UserConfig {
     server: {},
     ai: {},
     package_management: {},
-  }) as unknown as UserConfig;
+  };
+  return UserConfigSchema.parse(defaultConfig) as UserConfig;
 }

frontend/src/utils/zod-utils.ts

@@ -1,19 +1,19 @@
+/* Copyright 2024 Marimo. All rights reserved. */
+
 import z from "zod";
 
 export function isZodArray<T>(
-  schema: z.ZodType<unknown>,
-): schema is z.ZodArray<z.ZodType<unknown>> {
+  schema: z.ZodType,
+): schema is z.ZodArray<z.ZodType> {
   return schema instanceof z.ZodArray;
 }
 
-export function isZodPipe(
-  schema: z.ZodType<unknown>,
-): schema is z.ZodPipe<z.ZodType<unknown>> {
+export function isZodPipe(schema: z.ZodType): schema is z.ZodPipe<z.ZodType> {
   return schema instanceof z.ZodPipe;
 }
 
 export function isZodTuple(
-  schema: z.ZodType<unknown>,
-): schema is z.ZodTuple<z.ZodType<unknown>[]> {
+  schema: z.ZodType,
+): schema is z.ZodTuple<z.ZodType[]> {
   return schema instanceof z.ZodTuple;
 }