@elevasis/ui 2.66.0 → 2.68.0

package/dist/chunk-3MEXPLWT.js

@@ -0,0 +1,265 @@
+import { TextInput, Textarea, Radio, Stack, Checkbox, Select, NumberInput, Button } from '@mantine/core';
+import { useForm } from '@mantine/form';
+import { jsx, jsxs } from 'react/jsx-runtime';
+import { z } from 'zod';
+
+// src/components/forms/ZodFormRenderer.tsx
+function FormFieldRenderer({ field, form, richTextRenderer }) {
+  const commonProps = {
+    label: field.label,
+    description: field.description,
+    placeholder: field.placeholder,
+    required: field.required,
+    ...form.getInputProps(field.name)
+  };
+  switch (field.type) {
+    case "text":
+      return /* @__PURE__ */ jsx(TextInput, { ...commonProps });
+    case "textarea":
+      return /* @__PURE__ */ jsx(Textarea, { ...commonProps, minRows: 3, autosize: true });
+    case "number":
+      return /* @__PURE__ */ jsx(NumberInput, { ...commonProps, min: field.min, max: field.max });
+    case "select":
+      return /* @__PURE__ */ jsx(
+        Select,
+        {
+          ...commonProps,
+          data: field.options?.map((opt) => ({
+            label: opt.label,
+            value: String(opt.value)
+          })) || []
+        }
+      );
+    case "checkbox":
+      return /* @__PURE__ */ jsx(Checkbox, { ...commonProps, ...form.getInputProps(field.name, { type: "checkbox" }) });
+    case "radio":
+      return /* @__PURE__ */ jsx(Radio.Group, { ...commonProps, children: /* @__PURE__ */ jsx(Stack, { gap: "xs", children: field.options?.map((opt) => /* @__PURE__ */ jsx(Radio, { value: String(opt.value), label: opt.label }, opt.value)) }) });
+    case "richtext": {
+      const inputProps = form.getInputProps(field.name);
+      if (richTextRenderer) {
+        return richTextRenderer({
+          content: inputProps.value || "",
+          onChange: (content) => form.setFieldValue(field.name, content),
+          placeholder: field.placeholder
+        });
+      }
+      return /* @__PURE__ */ jsx(Textarea, { ...commonProps, minRows: 5, autosize: true });
+    }
+    default:
+      return /* @__PURE__ */ jsx(TextInput, { ...commonProps });
+  }
+}
+function toJsonSchema(zodSchema) {
+  return z.toJSONSchema(zodSchema);
+}
+function humanizeKey(name) {
+  return name.replace(/([A-Z])/g, " $1").replace(/^./, (s) => s.toUpperCase());
+}
+function unwrapNullable(schema) {
+  if (Array.isArray(schema.anyOf)) {
+    const nonNull = schema.anyOf.filter((s) => s.type !== "null");
+    if (nonNull.length === 1) return { ...nonNull[0], description: schema.description ?? nonNull[0].description };
+  }
+  return schema;
+}
+function defaultForLeaf(schema) {
+  if (schema.default !== void 0) return schema.default;
+  if (Array.isArray(schema.enum) && schema.enum.length > 0) return schema.enum[0];
+  switch (schema.type) {
+    case "string":
+      return "";
+    case "integer":
+    case "number":
+      return 0;
+    case "boolean":
+      return false;
+    case "array":
+      return [];
+    case "object":
+      return schema.properties ? extractDefaults(schema) : {};
+    default:
+      return void 0;
+  }
+}
+function extractDefaults(jsonSchema) {
+  if (jsonSchema.type !== "object" || !jsonSchema.properties) return {};
+  const result = {};
+  for (const [key, propSchema] of Object.entries(jsonSchema.properties)) {
+    result[key] = defaultForLeaf(unwrapNullable(propSchema));
+  }
+  return result;
+}
+function propSchemaToFormField(name, raw, required) {
+  const schema = unwrapNullable(raw);
+  const label = humanizeKey(name);
+  const description = schema.description ?? "";
+  if (Array.isArray(schema.enum) && schema.enum.length > 0) {
+    const values = schema.enum.filter((v) => typeof v === "string" || typeof v === "number");
+    return {
+      name,
+      label,
+      type: "select",
+      required,
+      placeholder: "",
+      description,
+      options: values.map((v) => ({ label: String(v), value: typeof v === "number" ? v : String(v) })),
+      defaultValue: schema.default ?? values[0]
+    };
+  }
+  switch (schema.type) {
+    case "string": {
+      const isLong = (schema.maxLength ?? 0) > 200;
+      return {
+        name,
+        label,
+        type: isLong ? "textarea" : "text",
+        required,
+        placeholder: "",
+        description,
+        defaultValue: schema.default ?? ""
+      };
+    }
+    case "number":
+    case "integer": {
+      const field = {
+        name,
+        label,
+        type: "number",
+        required,
+        placeholder: "",
+        description,
+        defaultValue: schema.default ?? 0
+      };
+      if (typeof schema.minimum === "number" && schema.minimum > Number.MIN_SAFE_INTEGER) field.min = schema.minimum;
+      if (typeof schema.maximum === "number" && schema.maximum < Number.MAX_SAFE_INTEGER) field.max = schema.maximum;
+      return field;
+    }
+    case "boolean":
+      return {
+        name,
+        label,
+        type: "checkbox",
+        required,
+        placeholder: "",
+        description,
+        defaultValue: schema.default ?? false
+      };
+    default:
+      return null;
+  }
+}
+function jsonSchemaToFormFields(jsonSchema) {
+  const fields = [];
+  const initialValues = {};
+  if (jsonSchema.type !== "object" || !jsonSchema.properties) {
+    fields.push({ name: "__input__", label: "Input (JSON)", fallback: true });
+    initialValues["__input__"] = jsonSchema.default !== void 0 ? JSON.stringify(jsonSchema.default, null, 2) : "";
+    return { fields, initialValues, isObject: false };
+  }
+  const required = new Set(jsonSchema.required ?? []);
+  for (const [name, propSchemaRaw] of Object.entries(jsonSchema.properties)) {
+    const propSchema = unwrapNullable(propSchemaRaw);
+    const isRequired = required.has(name) && propSchema.default === void 0;
+    const formField = propSchemaToFormField(name, propSchema, isRequired);
+    if (formField) {
+      fields.push(formField);
+      initialValues[name] = propSchema.default ?? formField.defaultValue;
+    } else {
+      fields.push({ name, label: humanizeKey(name), fallback: true });
+      initialValues[name] = propSchema.default !== void 0 ? JSON.stringify(propSchema.default, null, 2) : "";
+    }
+  }
+  return { fields, initialValues, isObject: true };
+}
+function sanitizeInput(schema, value) {
+  const jsonSchema = toJsonSchema(schema);
+  const emptyParse = schema.safeParse({});
+  const baseDefaults = emptyParse.success && emptyParse.data && typeof emptyParse.data === "object" && !Array.isArray(emptyParse.data) ? emptyParse.data : extractDefaults(jsonSchema);
+  if (value === null || value === void 0 || typeof value !== "object" || Array.isArray(value)) {
+    return baseDefaults;
+  }
+  if (jsonSchema.type !== "object" || !jsonSchema.properties) {
+    const parsed = schema.safeParse(value);
+    return parsed.success && parsed.data && typeof parsed.data === "object" && !Array.isArray(parsed.data) ? parsed.data : baseDefaults;
+  }
+  const raw = value;
+  const result = { ...baseDefaults };
+  if (schema instanceof z.ZodObject) {
+    const shape = schema.shape;
+    for (const key of Object.keys(jsonSchema.properties)) {
+      if (key in raw && shape[key]) {
+        const fieldParsed = shape[key].safeParse(raw[key]);
+        if (fieldParsed.success) {
+          result[key] = fieldParsed.data;
+        }
+      }
+    }
+  }
+  return result;
+}
+function ZodFormRenderer({
+  schema,
+  defaults,
+  onSubmit,
+  submitLabel = "Submit",
+  isPending = false
+}) {
+  const jsonSchema = toJsonSchema(schema);
+  const { fields, initialValues, isObject } = jsonSchemaToFormFields(jsonSchema);
+  const mergedInitialValues = { ...initialValues };
+  if (isObject && defaults) {
+    for (const [key, value] of Object.entries(defaults)) {
+      if (value !== void 0) mergedInitialValues[key] = value;
+    }
+  } else if (!isObject && defaults !== void 0) {
+    mergedInitialValues["__input__"] = JSON.stringify(defaults, null, 2);
+  }
+  const form = useForm({ initialValues: mergedInitialValues });
+  const handleSubmit = (values) => {
+    const coerced = {};
+    for (const field of fields) {
+      const raw = values[field.name];
+      if ("fallback" in field) {
+        try {
+          coerced[field.name] = raw !== "" && raw !== void 0 ? JSON.parse(raw) : void 0;
+        } catch {
+          coerced[field.name] = raw;
+        }
+      } else {
+        coerced[field.name] = raw;
+      }
+    }
+    const payload = isObject ? coerced : coerced["__input__"] ?? coerced;
+    const parsed = schema.safeParse(payload);
+    if (!parsed.success) {
+      for (const issue of parsed.error.issues) {
+        const path = issue.path.join(".");
+        if (path) form.setFieldError(path, issue.message);
+      }
+      return;
+    }
+    void onSubmit(parsed.data);
+  };
+  return /* @__PURE__ */ jsx("form", { onSubmit: form.onSubmit(handleSubmit), children: /* @__PURE__ */ jsxs(Stack, { children: [
+    fields.map((field) => {
+      if ("fallback" in field) {
+        return /* @__PURE__ */ jsx(
+          Textarea,
+          {
+            label: field.label,
+            placeholder: "Enter JSON value",
+            minRows: 3,
+            autosize: true,
+            ...form.getInputProps(field.name),
+            error: form.errors[field.name]
+          },
+          field.name
+        );
+      }
+      return /* @__PURE__ */ jsx(FormFieldRenderer, { field, form }, field.name);
+    }),
+    /* @__PURE__ */ jsx(Button, { type: "submit", loading: isPending, fullWidth: true, children: submitLabel })
+  ] }) });
+}
+
+export { FormFieldRenderer, ZodFormRenderer, sanitizeInput };

package/dist/{chunk-XNW3O6QW.js → chunk-5NRJ2BLQ.js}

@@ -1,5 +1,5 @@
 import { OrganizationContext } from './chunk-DD3CCMCZ.js';
-import { APIClientError } from './chunk-I7BZVVVU.js';
+import { APIClientError } from './chunk-L3HFJFYF.js';
 import { createContext, useContext, useMemo, useCallback } from 'react';
 import { jsx } from 'react/jsx-runtime';