@elevasis/ui 2.34.0 → 2.35.0

package/dist/chunk-3MEXPLWT.js

@@ -1,265 +0,0 @@
-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-3ZMAGTWF.js

@@ -1,18 +0,0 @@
-import { useMemo } from 'react';
-
-// src/execution/hooks/useMergedExecution.ts
-function useMergedExecution(fetchedExecution, streamingLogs) {
-  return useMemo(() => {
-    if (!fetchedExecution) return void 0;
-    if (!streamingLogs || streamingLogs.length === 0) return fetchedExecution;
-    const existingKeys = new Set(fetchedExecution.executionLogs.map((log) => `${log.timestamp}:${log.message}`));
-    const newLogs = streamingLogs.filter((log) => !existingKeys.has(`${log.timestamp}:${log.message}`));
-    if (newLogs.length === 0) return fetchedExecution;
-    return {
-      ...fetchedExecution,
-      executionLogs: [...fetchedExecution.executionLogs, ...newLogs].sort((a, b) => a.timestamp - b.timestamp)
-    };
-  }, [fetchedExecution, streamingLogs]);
-}
-
-export { useMergedExecution };