masumi-schema-validator-component 0.1.0

package/dist/index.js

@@ -0,0 +1,675 @@
+'use strict';
+
+var zod = require('zod');
+var React2 = require('react');
+var jsxRuntime = require('react/jsx-runtime');
+var clsx = require('clsx');
+var tailwindMerge = require('tailwind-merge');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var React2__default = /*#__PURE__*/_interopDefault(React2);
+var clsx__default = /*#__PURE__*/_interopDefault(clsx);
+
+// src/lib/job-input-schema.ts
+var ValidJobInputTypes = /* @__PURE__ */ ((ValidJobInputTypes2) => {
+  ValidJobInputTypes2["STRING"] = "string";
+  ValidJobInputTypes2["TEXTAREA"] = "textarea";
+  ValidJobInputTypes2["NUMBER"] = "number";
+  ValidJobInputTypes2["BOOLEAN"] = "boolean";
+  ValidJobInputTypes2["OPTION"] = "option";
+  ValidJobInputTypes2["FILE"] = "file";
+  ValidJobInputTypes2["NONE"] = "none";
+  return ValidJobInputTypes2;
+})(ValidJobInputTypes || {});
+var ValidJobInputValidationTypes = /* @__PURE__ */ ((ValidJobInputValidationTypes2) => {
+  ValidJobInputValidationTypes2["MIN"] = "min";
+  ValidJobInputValidationTypes2["MAX"] = "max";
+  ValidJobInputValidationTypes2["FORMAT"] = "format";
+  ValidJobInputValidationTypes2["OPTIONAL"] = "optional";
+  return ValidJobInputValidationTypes2;
+})(ValidJobInputValidationTypes || {});
+var ValidJobInputFormatValues = /* @__PURE__ */ ((ValidJobInputFormatValues2) => {
+  ValidJobInputFormatValues2["URL"] = "url";
+  ValidJobInputFormatValues2["EMAIL"] = "email";
+  ValidJobInputFormatValues2["INTEGER"] = "integer";
+  ValidJobInputFormatValues2["NON_EMPTY"] = "nonempty";
+  return ValidJobInputFormatValues2;
+})(ValidJobInputFormatValues || {});
+var optionalValidationSchema = zod.z.object({
+  validation: zod.z.enum(["optional" /* OPTIONAL */]),
+  value: zod.z.enum(["true", "false"])
+});
+var minValidationSchema = zod.z.object({
+  validation: zod.z.enum(["min" /* MIN */]),
+  value: zod.z.number({ coerce: true }).int().min(0)
+});
+var maxValidationSchema = zod.z.object({
+  validation: zod.z.enum(["max" /* MAX */]),
+  value: zod.z.number({ coerce: true }).int().min(0)
+});
+var formatUrlValidationSchema = zod.z.object({
+  validation: zod.z.enum(["format" /* FORMAT */]),
+  value: zod.z.enum(["url" /* URL */])
+});
+var formatEmailValidationSchema = zod.z.object({
+  validation: zod.z.enum(["format" /* FORMAT */]),
+  value: zod.z.enum(["email" /* EMAIL */])
+});
+var formatIntegerValidationSchema = zod.z.object({
+  validation: zod.z.enum(["format" /* FORMAT */]),
+  value: zod.z.enum(["integer" /* INTEGER */])
+});
+var formatNonEmptyValidationSchema = zod.z.object({
+  validation: zod.z.enum(["format" /* FORMAT */]),
+  value: zod.z.enum(["nonempty" /* NON_EMPTY */])
+});
+var jobInputStringSchema = zod.z.object({
+  id: zod.z.string().min(1),
+  type: zod.z.enum(["string" /* STRING */]),
+  name: zod.z.string().min(1),
+  data: zod.z.object({
+    placeholder: zod.z.string().optional(),
+    description: zod.z.string().optional()
+  }).optional(),
+  validations: zod.z.array(
+    optionalValidationSchema.or(minValidationSchema).or(maxValidationSchema).or(formatNonEmptyValidationSchema).or(formatUrlValidationSchema).or(formatEmailValidationSchema)
+  ).optional()
+});
+var jobInputTextareaSchema = zod.z.object({
+  id: zod.z.string().min(1),
+  type: zod.z.enum(["textarea" /* TEXTAREA */]),
+  name: zod.z.string().min(1),
+  data: zod.z.object({
+    placeholder: zod.z.string().optional(),
+    description: zod.z.string().optional()
+  }).optional(),
+  validations: zod.z.array(
+    optionalValidationSchema.or(minValidationSchema).or(maxValidationSchema).or(formatNonEmptyValidationSchema)
+  ).optional()
+});
+var jobInputNumberSchema = zod.z.object({
+  id: zod.z.string().min(1),
+  type: zod.z.enum(["number" /* NUMBER */]),
+  name: zod.z.string().min(1),
+  data: zod.z.object({
+    placeholder: zod.z.string().optional(),
+    description: zod.z.string().optional()
+  }).optional(),
+  validations: zod.z.array(
+    optionalValidationSchema.or(minValidationSchema).or(maxValidationSchema).or(formatIntegerValidationSchema)
+  ).optional()
+});
+var jobInputBooleanSchema = zod.z.object({
+  id: zod.z.string().min(1),
+  type: zod.z.enum(["boolean" /* BOOLEAN */]),
+  name: zod.z.string().min(1),
+  data: zod.z.object({
+    placeholder: zod.z.string().optional(),
+    description: zod.z.string().optional()
+  }).optional(),
+  validations: zod.z.array(optionalValidationSchema).optional()
+});
+var jobInputOptionSchema = zod.z.object({
+  id: zod.z.string().min(1),
+  type: zod.z.enum(["option" /* OPTION */]),
+  name: zod.z.string().min(1),
+  data: zod.z.object({
+    values: zod.z.array(zod.z.string().min(1)).min(1),
+    placeholder: zod.z.string().optional(),
+    description: zod.z.string().optional()
+  }),
+  validations: zod.z.array(
+    optionalValidationSchema.or(minValidationSchema).or(maxValidationSchema)
+  ).optional()
+});
+var jobInputFileSchema = zod.z.object({
+  id: zod.z.string().min(1),
+  type: zod.z.enum(["file" /* FILE */]),
+  name: zod.z.string().min(1),
+  data: zod.z.object({
+    accept: zod.z.string().optional(),
+    maxSize: zod.z.string().optional(),
+    multiple: zod.z.boolean().optional(),
+    description: zod.z.string().optional(),
+    outputFormat: zod.z.string().optional()
+  }),
+  validations: zod.z.array(optionalValidationSchema).optional()
+});
+var jobInputNoneSchema = zod.z.object({
+  id: zod.z.string().min(1),
+  type: zod.z.enum(["none" /* NONE */]),
+  name: zod.z.string().min(1),
+  data: zod.z.object({
+    description: zod.z.string().min(1).optional()
+  }).optional()
+});
+var jobInputSchema = jobInputStringSchema.or(jobInputTextareaSchema).or(jobInputNumberSchema).or(jobInputBooleanSchema).or(jobInputOptionSchema).or(jobInputFileSchema).or(jobInputNoneSchema);
+var makeZodSchemaFromJobInputSchema = (jobInputSchema2) => {
+  switch (jobInputSchema2.type) {
+    case "string" /* STRING */:
+      return makeZodSchemaFromJobInputStringSchema(jobInputSchema2);
+    case "textarea" /* TEXTAREA */:
+      return makeZodSchemaFromJobInputTextareaSchema(jobInputSchema2);
+    case "number" /* NUMBER */:
+      return makeZodSchemaFromJobInputNumberSchema(jobInputSchema2);
+    case "boolean" /* BOOLEAN */:
+      return makeZodSchemaFromJobInputBooleanSchema();
+    case "option" /* OPTION */:
+      return makeZodSchemaFromJobInputOptionSchema(jobInputSchema2);
+    case "file" /* FILE */:
+      return makeZodSchemaFromJobInputFileSchema(jobInputSchema2);
+    case "none" /* NONE */:
+      return zod.z.never().nullable();
+  }
+};
+var makeZodSchemaFromJobInputStringSchema = (jobInputStringSchema2) => {
+  const { validations } = jobInputStringSchema2;
+  const defaultSchema = zod.z.string();
+  if (!validations) return defaultSchema;
+  let canBeOptional = false;
+  const schema = validations.reduce((acc, cur) => {
+    const { validation, value } = cur;
+    switch (validation) {
+      case "min" /* MIN */:
+        return acc.min(value);
+      case "max" /* MAX */:
+        return acc.max(value);
+      case "format" /* FORMAT */:
+        switch (value) {
+          case "url" /* URL */:
+            return acc.url();
+          case "email" /* EMAIL */:
+            return acc.email();
+          case "nonempty" /* NON_EMPTY */:
+            return acc.min(1);
+          default:
+            return acc;
+        }
+      case "optional" /* OPTIONAL */:
+        canBeOptional = value === "true";
+        return acc;
+    }
+  }, defaultSchema);
+  return canBeOptional ? schema.optional() : schema;
+};
+var makeZodSchemaFromJobInputTextareaSchema = (jobInputTextareaSchema2) => {
+  const { validations } = jobInputTextareaSchema2;
+  const defaultSchema = zod.z.string();
+  if (!validations) return defaultSchema;
+  let canBeOptional = false;
+  const schema = validations.reduce((acc, cur) => {
+    const { validation, value } = cur;
+    switch (validation) {
+      case "min" /* MIN */:
+        return acc.min(value);
+      case "max" /* MAX */:
+        return acc.max(value);
+      case "format" /* FORMAT */:
+        switch (value) {
+          case "nonempty" /* NON_EMPTY */:
+            return acc.min(1);
+          default:
+            return acc;
+        }
+      case "optional" /* OPTIONAL */:
+        canBeOptional = value === "true";
+        return acc;
+    }
+  }, defaultSchema);
+  return canBeOptional ? schema.optional() : schema;
+};
+var makeZodSchemaFromJobInputNumberSchema = (jobInputNumberSchema2) => {
+  const { validations } = jobInputNumberSchema2;
+  const defaultSchema = zod.z.number({ coerce: true });
+  if (!validations) return defaultSchema;
+  let canBeOptional = false;
+  const schema = validations.reduce((acc, cur) => {
+    const { validation, value } = cur;
+    switch (validation) {
+      case "min" /* MIN */:
+        return acc.min(value);
+      case "max" /* MAX */:
+        return acc.max(value);
+      case "format" /* FORMAT */:
+        switch (value) {
+          case "integer" /* INTEGER */:
+            return acc.int();
+          default:
+            return acc;
+        }
+      case "optional" /* OPTIONAL */:
+        canBeOptional = value === "true";
+        return acc;
+    }
+  }, defaultSchema);
+  return canBeOptional ? schema.optional() : schema;
+};
+var makeZodSchemaFromJobInputBooleanSchema = () => {
+  return zod.z.boolean();
+};
+var makeZodSchemaFromJobInputOptionSchema = (jobInputOptionSchema2) => {
+  const {
+    data: { values },
+    validations
+  } = jobInputOptionSchema2;
+  const defaultSchema = zod.z.array(
+    zod.z.number().int().nonnegative().max(values.length - 1)
+  );
+  if (!validations) return defaultSchema;
+  let canBeOptional = false;
+  const schema = validations.reduce((acc, cur) => {
+    const { validation, value } = cur;
+    switch (validation) {
+      case "min" /* MIN */:
+        return acc.min(value);
+      case "max" /* MAX */:
+        return acc.max(value);
+      case "optional" /* OPTIONAL */:
+        canBeOptional = value === "true";
+        return acc;
+    }
+  }, defaultSchema);
+  return canBeOptional ? schema.optional() : schema;
+};
+var makeZodSchemaFromJobInputFileSchema = (jobInputFileSchema2) => {
+  const { validations } = jobInputFileSchema2;
+  const defaultSchema = zod.z.string();
+  if (!validations) return defaultSchema;
+  let canBeOptional = false;
+  const schema = validations.reduce((acc, cur) => {
+    const { validation, value } = cur;
+    switch (validation) {
+      case "optional" /* OPTIONAL */:
+        canBeOptional = value === "true";
+        return acc;
+      default:
+        return acc;
+    }
+  }, defaultSchema);
+  return canBeOptional ? schema.optional() : schema;
+};
+var isOptional = (jobInputSchema2) => {
+  if (!("validations" in jobInputSchema2) || !jobInputSchema2.validations)
+    return false;
+  return jobInputSchema2.validations.some(
+    (v) => v.validation === "optional" /* OPTIONAL */ && v.value === "true"
+  );
+};
+var isSingleOption = (jobInputSchema2) => {
+  if (jobInputSchema2.type !== "option" /* OPTION */) return false;
+  if (!("validations" in jobInputSchema2) || !jobInputSchema2.validations)
+    return false;
+  const minValidation = jobInputSchema2.validations.find(
+    (v) => v.validation === "min" /* MIN */
+  );
+  const maxValidation = jobInputSchema2.validations.find(
+    (v) => v.validation === "max" /* MAX */
+  );
+  return minValidation?.value === 1 && maxValidation?.value === 1;
+};
+var getDefaultValue = (jobInputSchema2) => {
+  const { type } = jobInputSchema2;
+  switch (type) {
+    case "string" /* STRING */:
+      return "";
+    case "textarea" /* TEXTAREA */:
+      return "";
+    case "boolean" /* BOOLEAN */:
+      return false;
+    case "number" /* NUMBER */:
+      return null;
+    case "option" /* OPTION */:
+      return [];
+    case "file" /* FILE */:
+      return null;
+    case "none" /* NONE */:
+      return null;
+  }
+};
+
+// src/lib/validation.ts
+function validateSchemaWithZod(input) {
+  let parsed;
+  try {
+    parsed = JSON.parse(input);
+  } catch (e) {
+    const match = e.message.match(/at position (\d+)/);
+    let line;
+    if (match) {
+      const pos = parseInt(match[1], 10);
+      line = input.slice(0, pos).split("\n").length;
+    }
+    return {
+      valid: false,
+      errors: [{ message: "Invalid JSON: " + e.message, line }]
+    };
+  }
+  const errors = [];
+  const schemas = [];
+  const getLine = (key) => {
+    const idx = input.indexOf('"' + key + '"');
+    if (idx === -1) return void 0;
+    return input.slice(0, idx).split("\n").length;
+  };
+  let schemasToValidate;
+  if (parsed.input_data && Array.isArray(parsed.input_data)) {
+    schemasToValidate = parsed.input_data;
+  } else if (Array.isArray(parsed)) {
+    schemasToValidate = parsed;
+  } else {
+    schemasToValidate = [parsed];
+  }
+  schemasToValidate.forEach((schema, index) => {
+    try {
+      const validatedSchema = jobInputSchema.parse(schema);
+      schemas.push(validatedSchema);
+    } catch (zodError) {
+      if (zodError.errors) {
+        zodError.errors.forEach((error) => {
+          errors.push({
+            message: `Schema ${index + 1}: ${error.message}`,
+            line: getLine(error.path?.[0] || "")
+          });
+        });
+      } else {
+        errors.push({
+          message: `Schema ${index + 1}: ${zodError.message}`,
+          line: getLine("type")
+        });
+      }
+    }
+  });
+  if (errors.length > 0) {
+    return { valid: false, errors };
+  }
+  return {
+    valid: true,
+    errors: [],
+    parsedSchemas: schemas
+  };
+}
+var Label = React2__default.default.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsxRuntime.jsx("label", { ref, className: cn("text-sm font-medium leading-none peer-disabled:cursor-not-allowed peer-disabled:opacity-70", className), ...props }));
+Label.displayName = "Label";
+var Input = React2__default.default.forwardRef(({ className, type, ...props }, ref) => /* @__PURE__ */ jsxRuntime.jsx(
+  "input",
+  {
+    type,
+    className: cn(
+      "flex h-10 w-full rounded-md border border-input bg-background px-3 py-2 text-sm ring-offset-background file:border-0 file:bg-transparent file:text-sm file:font-medium placeholder:text-muted-foreground focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 disabled:cursor-not-allowed disabled:opacity-50",
+      className
+    ),
+    ref,
+    ...props
+  }
+));
+Input.displayName = "Input";
+var Textarea = React2__default.default.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsxRuntime.jsx(
+  "textarea",
+  {
+    className: cn(
+      "flex min-h-[80px] w-full rounded-md border border-input bg-background px-3 py-2 text-sm ring-offset-background placeholder:text-muted-foreground focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 disabled:cursor-not-allowed disabled:opacity-50",
+      className
+    ),
+    ref,
+    ...props
+  }
+));
+Textarea.displayName = "Textarea";
+var Checkbox = React2__default.default.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsxRuntime.jsx("input", { type: "checkbox", ref, className: cn("h-4 w-4 rounded border-gray-300 text-primary focus:ring-primary", className), ...props }));
+Checkbox.displayName = "Checkbox";
+function JobInputRenderer({
+  jobInputSchema: jobInputSchema2,
+  value,
+  onChange,
+  disabled
+}) {
+  const { id, name, type, data } = jobInputSchema2;
+  const description = data?.description;
+  const placeholder = "placeholder" in (data || {}) ? data.placeholder : "";
+  const renderInput = () => {
+    switch (type) {
+      case "string" /* STRING */:
+        return /* @__PURE__ */ jsxRuntime.jsx(
+          Input,
+          {
+            id,
+            value: value || "",
+            onChange: (e) => onChange(e.target.value),
+            placeholder,
+            disabled
+          }
+        );
+      case "textarea" /* TEXTAREA */:
+        return /* @__PURE__ */ jsxRuntime.jsx(
+          Textarea,
+          {
+            id,
+            value: value || "",
+            onChange: (e) => onChange(e.target.value),
+            placeholder,
+            disabled
+          }
+        );
+      case "number" /* NUMBER */:
+        return /* @__PURE__ */ jsxRuntime.jsx(
+          Input,
+          {
+            id,
+            type: "number",
+            value: value !== null ? String(value) : "",
+            onChange: (e) => {
+              const val = e.target.value;
+              onChange(val === "" ? null : Number(val));
+            },
+            placeholder,
+            disabled
+          }
+        );
+      case "boolean" /* BOOLEAN */:
+        return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center space-x-2", children: [
+          /* @__PURE__ */ jsxRuntime.jsx(
+            Checkbox,
+            {
+              id,
+              checked: !!value,
+              onChange: (e) => onChange(e.target.checked),
+              disabled
+            }
+          ),
+          /* @__PURE__ */ jsxRuntime.jsx(
+            "label",
+            {
+              htmlFor: id,
+              className: "text-sm font-medium leading-none peer-disabled:cursor-not-allowed peer-disabled:opacity-70",
+              children: placeholder || "Yes"
+            }
+          )
+        ] });
+      case "option" /* OPTION */:
+        const options = data.values || [];
+        return /* @__PURE__ */ jsxRuntime.jsxs(
+          "select",
+          {
+            id,
+            className: "flex h-10 w-full items-center justify-between rounded-md border border-input bg-background px-3 py-2 text-sm ring-offset-background placeholder:text-muted-foreground focus:outline-none focus:ring-2 focus:ring-ring focus:ring-offset-2 disabled:cursor-not-allowed disabled:opacity-50",
+            value: Array.isArray(value) && value.length > 0 ? value[0] : "",
+            onChange: (e) => {
+              const selectedIndex = options.indexOf(e.target.value);
+              onChange(selectedIndex >= 0 ? [selectedIndex] : []);
+            },
+            disabled,
+            children: [
+              /* @__PURE__ */ jsxRuntime.jsx("option", { value: "", children: "Select..." }),
+              options.map((opt) => /* @__PURE__ */ jsxRuntime.jsx("option", { value: opt, children: opt }, opt))
+            ]
+          }
+        );
+      case "file" /* FILE */:
+        return /* @__PURE__ */ jsxRuntime.jsx(
+          Input,
+          {
+            id,
+            type: "file",
+            disabled,
+            onChange: () => {
+            }
+          }
+        );
+      default:
+        return /* @__PURE__ */ jsxRuntime.jsxs("div", { children: [
+          "Unsupported input type: ",
+          type
+        ] });
+    }
+  };
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "space-y-2", children: [
+    /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex flex-col space-y-1", children: [
+      /* @__PURE__ */ jsxRuntime.jsxs(Label, { htmlFor: id, children: [
+        name,
+        "validations" in jobInputSchema2 && jobInputSchema2.validations?.some((v) => v.validation === "optional" && v.value === "true") && /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-muted-foreground font-normal ml-1", children: "(Optional)" })
+      ] }),
+      description && /* @__PURE__ */ jsxRuntime.jsx("p", { className: "text-sm text-muted-foreground", children: description })
+    ] }),
+    renderInput()
+  ] });
+}
+function cn(...inputs) {
+  return tailwindMerge.twMerge(clsx__default.default(inputs));
+}
+var Button = React2__default.default.forwardRef(
+  ({ className, variant = "default", ...props }, ref) => {
+    const variants = {
+      default: "bg-primary text-primary-foreground hover:bg-primary/90",
+      outline: "border border-input bg-background hover:bg-accent hover:text-accent-foreground",
+      destructive: "bg-destructive text-destructive-foreground hover:bg-destructive/90",
+      secondary: "bg-secondary text-secondary-foreground hover:bg-secondary/80",
+      ghost: "hover:bg-accent hover:text-accent-foreground",
+      link: "text-primary underline-offset-4 hover:underline"
+    };
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      "button",
+      {
+        ref,
+        className: cn(
+          "inline-flex items-center justify-center whitespace-nowrap rounded-md text-sm font-medium ring-offset-background transition-colors focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 disabled:pointer-events-none disabled:opacity-50 h-10 px-4 py-2",
+          variants[variant],
+          className
+        ),
+        ...props
+      }
+    );
+  }
+);
+Button.displayName = "Button";
+var Card = React2__default.default.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsxRuntime.jsx("div", { ref, className: cn("rounded-lg border bg-card text-card-foreground shadow-sm", className), ...props }));
+Card.displayName = "Card";
+var CardHeader = React2__default.default.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsxRuntime.jsx("div", { ref, className: cn("flex flex-col space-y-1.5 p-6", className), ...props }));
+CardHeader.displayName = "CardHeader";
+var CardTitle = React2__default.default.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsxRuntime.jsx("h3", { ref, className: cn("text-2xl font-semibold leading-none tracking-tight", className), ...props }));
+CardTitle.displayName = "CardTitle";
+var CardContent = React2__default.default.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsxRuntime.jsx("div", { ref, className: cn("p-6 pt-0", className), ...props }));
+CardContent.displayName = "CardContent";
+var Separator = React2__default.default.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsxRuntime.jsx("div", { ref, className: cn("shrink-0 bg-border h-[1px] w-full", className), ...props }));
+Separator.displayName = "Separator";
+function JobInputsFormRenderer({
+  jobInputSchemas,
+  onFormDataChange,
+  disabled = false,
+  className
+}) {
+  const [formData, setFormData] = React2.useState({});
+  React2.useEffect(() => {
+    const initialData = {};
+    jobInputSchemas.forEach((schema) => {
+      initialData[schema.id] = getDefaultValue(schema);
+    });
+    setFormData(initialData);
+  }, [jobInputSchemas]);
+  React2.useEffect(() => {
+    if (onFormDataChange) {
+      onFormDataChange(formData);
+    }
+  }, [formData, onFormDataChange]);
+  const handleFieldChange = (fieldId, value) => {
+    setFormData((prev) => ({
+      ...prev,
+      [fieldId]: value
+    }));
+  };
+  const handleClear = () => {
+    const clearedData = {};
+    jobInputSchemas.forEach((schema) => {
+      clearedData[schema.id] = getDefaultValue(schema);
+    });
+    setFormData(clearedData);
+  };
+  if (jobInputSchemas.length === 0) {
+    return /* @__PURE__ */ jsxRuntime.jsx(Card, { className, children: /* @__PURE__ */ jsxRuntime.jsx(CardContent, { className: "pt-6", children: /* @__PURE__ */ jsxRuntime.jsx("p", { className: "text-sm text-muted-foreground text-center", children: "No input fields defined in the schema." }) }) });
+  }
+  return /* @__PURE__ */ jsxRuntime.jsxs(Card, { className: cn("bg-muted/20", className), children: [
+    /* @__PURE__ */ jsxRuntime.jsxs(CardHeader, { children: [
+      /* @__PURE__ */ jsxRuntime.jsx(CardTitle, { className: "text-lg", children: "Rendered Form" }),
+      /* @__PURE__ */ jsxRuntime.jsx("p", { className: "text-sm text-muted-foreground", children: "This is how the form will appear in Sokosumi" })
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsxs(CardContent, { className: "space-y-6", children: [
+      /* @__PURE__ */ jsxRuntime.jsx("form", { className: "space-y-4", onSubmit: (e) => e.preventDefault(), children: jobInputSchemas.map((schema, index) => /* @__PURE__ */ jsxRuntime.jsxs("div", { children: [
+        /* @__PURE__ */ jsxRuntime.jsx(
+          JobInputRenderer,
+          {
+            jobInputSchema: schema,
+            value: formData[schema.id],
+            onChange: (value) => handleFieldChange(schema.id, value),
+            disabled
+          }
+        ),
+        index < jobInputSchemas.length - 1 && /* @__PURE__ */ jsxRuntime.jsx(Separator, { className: "my-4" })
+      ] }, schema.id)) }),
+      /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex justify-between items-center pt-4", children: [
+        /* @__PURE__ */ jsxRuntime.jsx(
+          Button,
+          {
+            type: "button",
+            variant: "outline",
+            onClick: handleClear,
+            disabled,
+            children: "Clear Form"
+          }
+        ),
+        /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "text-sm text-muted-foreground", children: [
+          Object.keys(formData).length,
+          " field",
+          Object.keys(formData).length !== 1 ? "s" : ""
+        ] })
+      ] })
+    ] })
+  ] });
+}
+
+exports.JobInputRenderer = JobInputRenderer;
+exports.JobInputsFormRenderer = JobInputsFormRenderer;
+exports.ValidJobInputFormatValues = ValidJobInputFormatValues;
+exports.ValidJobInputTypes = ValidJobInputTypes;
+exports.ValidJobInputValidationTypes = ValidJobInputValidationTypes;
+exports.formatEmailValidationSchema = formatEmailValidationSchema;
+exports.formatIntegerValidationSchema = formatIntegerValidationSchema;
+exports.formatNonEmptyValidationSchema = formatNonEmptyValidationSchema;
+exports.formatUrlValidationSchema = formatUrlValidationSchema;
+exports.getDefaultValue = getDefaultValue;
+exports.isOptional = isOptional;
+exports.isSingleOption = isSingleOption;
+exports.jobInputBooleanSchema = jobInputBooleanSchema;
+exports.jobInputFileSchema = jobInputFileSchema;
+exports.jobInputNoneSchema = jobInputNoneSchema;
+exports.jobInputNumberSchema = jobInputNumberSchema;
+exports.jobInputOptionSchema = jobInputOptionSchema;
+exports.jobInputSchema = jobInputSchema;
+exports.jobInputStringSchema = jobInputStringSchema;
+exports.jobInputTextareaSchema = jobInputTextareaSchema;
+exports.makeZodSchemaFromJobInputSchema = makeZodSchemaFromJobInputSchema;
+exports.maxValidationSchema = maxValidationSchema;
+exports.minValidationSchema = minValidationSchema;
+exports.optionalValidationSchema = optionalValidationSchema;
+exports.validateSchemaWithZod = validateSchemaWithZod;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map