@mastra/playground-ui 5.2.2-alpha.0 → 5.2.2-alpha.1

package/dist/index.es.js

@@ -50,11 +50,12 @@ import { v4 } from '@lukeed/uuid';
 import { RuntimeContext as RuntimeContext$2 } from '@mastra/core/runtime-context';
 import jsonSchemaToZod from 'json-schema-to-zod';
 import { parse } from 'superjson';
-import z$1, { z, ZodObject } from 'zod';
+import z$2, { z, ZodObject } from 'zod';
 import { AutoForm as AutoForm$1, buildZodFieldConfig } from '@autoform/react';
 import * as CheckboxPrimitive from '@radix-ui/react-checkbox';
 import { DayPicker } from 'react-day-picker';
-import { ZodProvider, getFieldConfigInZodStack, getDefaultValueInZodStack } from '@autoform/zod';
+import { ZodProvider, getFieldConfigInZodStack, getDefaultValueInZodStack } from '@autoform/zod/v4';
+import { z as z$1 } from 'zod/v3';
 import { CodeBlock as CodeBlock$1 } from 'react-code-block';
 import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
 import './index.css';export * from '@tanstack/react-query';
@@ -12939,48 +12940,28 @@ function inferFieldType(schema, fieldConfig) {
   if (schema instanceof z.ZodObject) return "object";
   if (schema instanceof z.ZodNumber) return "number";
   if (schema instanceof z.ZodBoolean) return "boolean";
-  if (schema instanceof z.ZodDate || schema?.isDatetime || schema?.isDate) return "date";
-  if (schema instanceof z.ZodString) return "string";
+  if (schema instanceof z.ZodString) {
+    const checks = schema._zod.def.checks || [];
+    const hasDateTimeCheck = checks.some(
+      //@ts-expect-error - zod string_format check has format property
+      (check) => check._zod.def.check === "string_format" && check._zod.def.format === "datetime"
+    );
+    if (hasDateTimeCheck) return "date";
+    return "string";
+  }
   if (schema instanceof z.ZodEnum) return "select";
-  if (schema instanceof z.ZodNativeEnum) return "select";
+  if (schema instanceof z$1.ZodNativeEnum) return "select";
   if (schema instanceof z.ZodArray) return "array";
   if (schema instanceof z.ZodRecord) return "record";
   return "string";
 }
 
-function extractNumberConstraints(schema) {
-  const constraints = {};
-  let baseSchema = getBaseSchema(schema);
-  if (baseSchema._def && baseSchema._def.checks) {
-    for (const check of baseSchema._def.checks) {
-      if (check.kind === "min" && check.inclusive) {
-        constraints.min = check.value;
-      } else if (check.kind === "max" && check.inclusive) {
-        constraints.max = check.value;
-      } else if (check.kind === "multipleOf") {
-        constraints.step = check.value;
-      }
-    }
-  }
-  return constraints;
-}
 function parseField(key, schema) {
   const baseSchema = getBaseSchema(schema);
-  let fieldConfig = getFieldConfigInZodStack(schema);
+  const fieldConfig = getFieldConfigInZodStack(schema);
   const type = inferFieldType(baseSchema, fieldConfig);
   const defaultValue = getDefaultValueInZodStack(schema);
-  if (type === "number" && baseSchema instanceof z.ZodNumber) {
-    const constraints = extractNumberConstraints(schema);
-    if (Object.keys(constraints).length > 0) {
-      if (!fieldConfig) {
-        fieldConfig = {};
-      }
-      if (typeof fieldConfig === "object") {
-        fieldConfig.inputProps = { ...fieldConfig?.inputProps, ...constraints };
-      }
-    }
-  }
-  const options = baseSchema._def?.values;
+  const options = baseSchema._zod.def?.entries;
   let optionValues = [];
   if (options) {
     if (!Array.isArray(options)) {
@@ -12990,16 +12971,16 @@ function parseField(key, schema) {
     }
   }
   let subSchema = [];
-  if (baseSchema instanceof z.ZodObject) {
+  if (baseSchema instanceof z$1.ZodObject || baseSchema instanceof z.ZodObject) {
     subSchema = Object.entries(baseSchema.shape).map(([key2, field]) => parseField(key2, field));
   }
-  if (baseSchema instanceof z.ZodArray) {
-    subSchema = [parseField("0", baseSchema._def.type)];
+  if (baseSchema instanceof z$1.ZodArray || baseSchema instanceof z.ZodArray) {
+    subSchema = [parseField("0", baseSchema._zod.def.element)];
   }
   return {
     key,
     type,
-    required: !schema.isOptional(),
+    required: !schema.optional(),
     default: defaultValue,
     description: baseSchema.description,
     fieldConfig,
@@ -13008,17 +12989,16 @@ function parseField(key, schema) {
   };
 }
 function getBaseSchema(schema) {
-  if ("innerType" in schema._def) {
-    return getBaseSchema(schema._def.innerType);
+  if ("innerType" in schema._zod.def) {
+    return getBaseSchema(schema._zod.def.innerType);
   }
-  if ("schema" in schema._def) {
-    return getBaseSchema(schema._def.schema);
+  if ("schema" in schema._zod.def) {
+    return getBaseSchema(schema._zod.def.schema);
   }
   return schema;
 }
 function parseSchema(schema) {
-  const objectSchema = schema instanceof z.ZodEffects ? schema.innerType() : schema;
-  const shape = objectSchema.shape;
+  const shape = schema.shape;
   const fields = Object.entries(shape).map(([key, field]) => parseField(key, field));
   return { fields };
 }
@@ -13028,6 +13008,10 @@ class CustomZodProvider extends ZodProvider {
     super(schema);
     this._schema = schema;
   }
+  validateSchema(values) {
+    const result = super.validateSchema(values);
+    return result;
+  }
   parseSchema() {
     return parseSchema(this._schema);
   }
@@ -13055,10 +13039,10 @@ function DynamicForm({
   }
   const normalizedSchema = (schema2) => {
     if (isEmptyZodObject(schema2)) {
-      return z$1.object({});
+      return z$2.object({});
     }
     if (isNotZodObject) {
-      return z$1.object({
+      return z$2.object({
         "​": schema2
       });
     }