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

package/dist/index.cjs.js

@@ -56,7 +56,8 @@ const z = require('zod');
 const react$3 = require('@autoform/react');
 const CheckboxPrimitive = require('@radix-ui/react-checkbox');
 const reactDayPicker = require('react-day-picker');
-const zod = require('@autoform/zod');
+const v4 = require('@autoform/zod/v4');
+const v3 = require('zod/v3');
 const reactCodeBlock = require('react-code-block');
 const reactQuery = require('@tanstack/react-query');
 
@@ -12972,48 +12973,28 @@ function inferFieldType(schema, fieldConfig) {
   if (schema instanceof z.z.ZodObject) return "object";
   if (schema instanceof z.z.ZodNumber) return "number";
   if (schema instanceof z.z.ZodBoolean) return "boolean";
-  if (schema instanceof z.z.ZodDate || schema?.isDatetime || schema?.isDate) return "date";
-  if (schema instanceof z.z.ZodString) return "string";
+  if (schema instanceof z.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.z.ZodEnum) return "select";
-  if (schema instanceof z.z.ZodNativeEnum) return "select";
+  if (schema instanceof v3.z.ZodNativeEnum) return "select";
   if (schema instanceof z.z.ZodArray) return "array";
   if (schema instanceof z.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 = zod.getFieldConfigInZodStack(schema);
+  const fieldConfig = v4.getFieldConfigInZodStack(schema);
   const type = inferFieldType(baseSchema, fieldConfig);
-  const defaultValue = zod.getDefaultValueInZodStack(schema);
-  if (type === "number" && baseSchema instanceof z.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 defaultValue = v4.getDefaultValueInZodStack(schema);
+  const options = baseSchema._zod.def?.entries;
   let optionValues = [];
   if (options) {
     if (!Array.isArray(options)) {
@@ -13023,16 +13004,16 @@ function parseField(key, schema) {
     }
   }
   let subSchema = [];
-  if (baseSchema instanceof z.z.ZodObject) {
+  if (baseSchema instanceof v3.z.ZodObject || baseSchema instanceof z.z.ZodObject) {
     subSchema = Object.entries(baseSchema.shape).map(([key2, field]) => parseField(key2, field));
   }
-  if (baseSchema instanceof z.z.ZodArray) {
-    subSchema = [parseField("0", baseSchema._def.type)];
+  if (baseSchema instanceof v3.z.ZodArray || baseSchema instanceof z.z.ZodArray) {
+    subSchema = [parseField("0", baseSchema._zod.def.element)];
   }
   return {
     key,
     type,
-    required: !schema.isOptional(),
+    required: !schema.optional(),
     default: defaultValue,
     description: baseSchema.description,
     fieldConfig,
@@ -13041,26 +13022,29 @@ 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.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 };
 }
-class CustomZodProvider extends zod.ZodProvider {
+class CustomZodProvider extends v4.ZodProvider {
   _schema;
   constructor(schema) {
     super(schema);
     this._schema = schema;
   }
+  validateSchema(values) {
+    const result = super.validateSchema(values);
+    return result;
+  }
   parseSchema() {
     return parseSchema(this._schema);
   }