@ixo/editor 6.32.1 → 6.34.0

package/dist/chunk-4PONO4US.js

@@ -0,0 +1,799 @@
+import {
+  parseHttpRequestInputs
+} from "./chunk-XPBKU3JX.js";
+import {
+  createReference,
+  hasReferences,
+  parseReferences
+} from "./chunk-JVROGQ7Q.js";
+import {
+  getAction,
+  getEventsForBlock,
+  getOutputSchemaForBlock
+} from "./chunk-IIIZZ4E4.js";
+
+// src/mantine/components/DataInput/DataInput.tsx
+import React2, { useState as useState2, useCallback, useMemo as useMemo2 } from "react";
+import { Input, ActionIcon as ActionIcon2, Tooltip, Group as Group2 } from "@mantine/core";
+import { IconVariable, IconX as IconX2 } from "@tabler/icons-react";
+
+// src/mantine/components/DataInput/BlockPropSelector.tsx
+import React, { useState, useMemo } from "react";
+import { Popover, Text, Stack, Group, ActionIcon, TextInput, ScrollArea, Badge, Box } from "@mantine/core";
+import { IconSearch, IconX, IconChevronRight, IconArrowLeft, IconBolt } from "@tabler/icons-react";
+
+// src/mantine/blocks/apiRequest/types.ts
+function parseResponseSchema(schemaString) {
+  if (!schemaString) return null;
+  try {
+    return JSON.parse(schemaString);
+  } catch (error) {
+    return null;
+  }
+}
+function validateResponseAgainstSchema(response, schema) {
+  const errors = [];
+  schema.fields.forEach((field) => {
+    const value = getNestedValueForValidation(response, field.path);
+    if (value === void 0) {
+      errors.push(`Missing field: ${field.path}`);
+    } else {
+      const actualType = Array.isArray(value) ? "array" : typeof value;
+      if (field.type === "object" && actualType !== "object") {
+        errors.push(`Type mismatch for ${field.path}: expected object, got ${actualType}`);
+      } else if (field.type === "array" && !Array.isArray(value)) {
+        errors.push(`Type mismatch for ${field.path}: expected array, got ${actualType}`);
+      } else if (field.type !== "object" && field.type !== "array" && actualType !== field.type) {
+        errors.push(`Type mismatch for ${field.path}: expected ${field.type}, got ${actualType}`);
+      }
+    }
+  });
+  return errors;
+}
+function getNestedValueForValidation(obj, path) {
+  return path.split(".").reduce((current, key) => {
+    return current?.[key];
+  }, obj);
+}
+
+// src/mantine/blocks/registry/conditionableProperties.ts
+var CONDITIONABLE_PROPERTIES = {
+  checkbox: [
+    {
+      name: "checked",
+      displayName: "Is checked",
+      type: "boolean",
+      description: "Whether the checkbox is currently checked"
+    },
+    {
+      name: "title",
+      displayName: "Title",
+      type: "string",
+      description: "The title text of the checkbox"
+    },
+    {
+      name: "description",
+      displayName: "Description",
+      type: "string",
+      description: "The description text of the checkbox"
+    },
+    {
+      name: "allowedCheckers",
+      displayName: "Allowed checkers",
+      type: "string",
+      description: "Who can check this checkbox"
+    }
+  ],
+  proposal: [
+    {
+      name: "status",
+      displayName: "Status",
+      type: "select",
+      selectOptions: [
+        { value: "draft", label: "Draft" },
+        { value: "created", label: "Created" }
+      ],
+      description: "The current status of the proposal"
+    },
+    {
+      name: "title",
+      displayName: "Title",
+      type: "string",
+      description: "The title of the proposal"
+    },
+    {
+      name: "description",
+      displayName: "Description",
+      type: "string",
+      description: "The description of the proposal"
+    },
+    {
+      name: "proposalId",
+      displayName: "Proposal ID",
+      type: "string",
+      description: "The unique identifier of the proposal"
+    }
+  ],
+  proposalVote: [
+    {
+      name: "status",
+      displayName: "Status",
+      type: "select",
+      selectOptions: [
+        { value: "open", label: "Open" },
+        { value: "passed", label: "Passed" },
+        { value: "rejected", label: "Rejected" },
+        { value: "executed", label: "Executed" },
+        { value: "closed", label: "Closed" }
+      ],
+      description: "The current status of the proposal vote"
+    },
+    {
+      name: "title",
+      displayName: "Title",
+      type: "string",
+      description: "The title of the proposal vote"
+    },
+    {
+      name: "subtitle",
+      displayName: "Subtitle",
+      type: "string",
+      description: "The subtitle of the proposal vote"
+    },
+    {
+      name: "daysLeft",
+      displayName: "Days left",
+      type: "number",
+      description: "Number of days remaining for voting"
+    },
+    {
+      name: "proposalId",
+      displayName: "Proposal ID",
+      type: "string",
+      description: "The unique identifier of the proposal"
+    }
+  ],
+  list: [
+    {
+      name: "title",
+      displayName: "Title",
+      type: "string",
+      description: "The title of the list"
+    },
+    {
+      name: "did",
+      displayName: "DID",
+      type: "string",
+      description: "The DID associated with the list"
+    },
+    {
+      name: "fragmentIdentifier",
+      displayName: "Fragment identifier",
+      type: "string",
+      description: "The fragment identifier for the list"
+    }
+  ],
+  overview: [
+    {
+      name: "did",
+      displayName: "DID",
+      type: "string",
+      description: "The DID associated with the overview"
+    }
+  ],
+  proposalActions: [
+    {
+      name: "proposalBlockId",
+      displayName: "Proposal block ID",
+      type: "string",
+      description: "The ID of the associated proposal block"
+    },
+    {
+      name: "actions",
+      displayName: "Actions",
+      type: "string",
+      description: "The JSON string of actions"
+    }
+  ],
+  apiRequest: [
+    {
+      name: "endpoint",
+      displayName: "Endpoint",
+      type: "string",
+      description: "The API endpoint URL"
+    },
+    {
+      name: "method",
+      displayName: "HTTP Method",
+      type: "select",
+      selectOptions: [
+        { value: "GET", label: "GET" },
+        { value: "POST", label: "POST" },
+        { value: "PUT", label: "PUT" },
+        { value: "DELETE", label: "DELETE" },
+        { value: "PATCH", label: "PATCH" }
+      ],
+      description: "The HTTP method for the request"
+    },
+    {
+      name: "response",
+      displayName: "Response",
+      type: "string",
+      description: "The response data from the API request"
+    },
+    {
+      name: "status",
+      displayName: "Status",
+      type: "select",
+      selectOptions: [
+        { value: "idle", label: "Idle" },
+        { value: "loading", label: "Loading" },
+        { value: "success", label: "Success" },
+        { value: "error", label: "Error" }
+      ],
+      description: "The current status of the API request"
+    },
+    {
+      name: "title",
+      displayName: "Title",
+      type: "string",
+      description: "The title of the API request block"
+    },
+    {
+      name: "description",
+      displayName: "Description",
+      type: "string",
+      description: "The description of the API request block"
+    }
+  ],
+  domainCreator: [
+    {
+      name: "title",
+      displayName: "Title",
+      type: "string",
+      description: "The title of the domain creator block"
+    },
+    {
+      name: "description",
+      displayName: "Description",
+      type: "string",
+      description: "Supporting description text for the domain creator block"
+    },
+    {
+      name: "surveySchema",
+      displayName: "Survey schema",
+      type: "string",
+      description: "JSON string containing the full survey definition with field types, titles, and structure"
+    },
+    {
+      name: "answers",
+      displayName: "Survey answers",
+      type: "string",
+      description: "JSON string containing current survey answers (can be updated by AI agents)"
+    },
+    {
+      name: "lastSubmission",
+      displayName: "Last submission data",
+      type: "string",
+      description: "JSON string from the last completed survey response"
+    },
+    {
+      name: "entityDid",
+      displayName: "Entity DID",
+      type: "string",
+      description: "The DID of the created entity"
+    },
+    {
+      name: "entityType",
+      displayName: "Entity Type",
+      type: "string",
+      description: "The type of entity created (e.g., dao, protocol)"
+    }
+  ],
+  email: [
+    {
+      name: "status",
+      displayName: "Status",
+      type: "select",
+      selectOptions: [
+        { value: "idle", label: "Idle" },
+        { value: "sending", label: "Sending" },
+        { value: "sent", label: "Sent" },
+        { value: "error", label: "Error" }
+      ],
+      description: "The current status of the email"
+    },
+    {
+      name: "lastSentAt",
+      displayName: "Last sent at",
+      type: "string",
+      description: "Timestamp when the email was last sent"
+    },
+    {
+      name: "templateName",
+      displayName: "Template",
+      type: "string",
+      description: "Selected email template name"
+    },
+    {
+      name: "title",
+      displayName: "Title",
+      type: "string",
+      description: "The title of the email block"
+    },
+    {
+      name: "error",
+      displayName: "Error",
+      type: "string",
+      description: "Error message if sending failed"
+    }
+  ],
+  governanceGroup: [
+    {
+      name: "coreAddress",
+      displayName: "Core Address",
+      type: "string",
+      description: "The DAO core contract address"
+    },
+    {
+      name: "groupAddress",
+      displayName: "Group Address",
+      type: "string",
+      description: "The voting group contract address"
+    },
+    {
+      name: "groupType",
+      displayName: "Group Type",
+      type: "select",
+      selectOptions: [
+        { value: "categorical", label: "Categorical" },
+        { value: "multisig", label: "Multisig" },
+        { value: "nftStaking", label: "NFT Staking" },
+        { value: "tokenStaking", label: "Token Staking" }
+      ],
+      description: "Type of governance group"
+    },
+    {
+      name: "title",
+      displayName: "Title",
+      type: "string",
+      description: "Title of the governance group block"
+    },
+    {
+      name: "description",
+      displayName: "Description",
+      type: "string",
+      description: "Description of the governance group block"
+    }
+  ],
+  flowLink: [
+    {
+      name: "title",
+      displayName: "Title",
+      type: "string",
+      description: "Block title"
+    },
+    {
+      name: "description",
+      displayName: "Description",
+      type: "string",
+      description: "Block description"
+    },
+    {
+      name: "linksCount",
+      displayName: "Links count",
+      type: "number",
+      description: "Number of configured links"
+    }
+  ],
+  action: [],
+  embed: []
+};
+function getConditionableProperties(blockType, block) {
+  const baseProperties = CONDITIONABLE_PROPERTIES[blockType] || [];
+  if (blockType === "apiRequest" && block?.props?.responseSchema) {
+    const schema = parseResponseSchema(block.props.responseSchema);
+    if (schema && schema.fields.length > 0) {
+      const schemaProperties = schema.fields.map((field) => ({
+        name: `response.${field.path}`,
+        displayName: field.displayName,
+        type: field.type,
+        description: field.description || `Response field: ${field.displayName}`
+      }));
+      const filteredBase = baseProperties.filter((prop) => prop.name !== "response");
+      return [...filteredBase, ...schemaProperties];
+    }
+  }
+  if (blockType === "action" && block?.props?.actionType) {
+    const actionDef = getAction(block.props.actionType);
+    const schema = getOutputSchemaForBlock(actionDef, block.props?.inputs);
+    if (schema.length > 0) {
+      return schema.map((field) => ({
+        name: `output.${field.path}`,
+        displayName: field.displayName,
+        type: field.type,
+        description: field.description || `Output field: ${field.displayName}`
+      }));
+    }
+    if (block.props.inputs) {
+      const parsed = parseHttpRequestInputs(block.props.inputs);
+      const schema2 = parsed.responseSchema;
+      if (schema2 && schema2.fields.length > 0) {
+        return schema2.fields.map((field) => ({
+          name: `output.${field.path}`,
+          displayName: field.displayName,
+          type: field.type,
+          description: field.description || `Output field: ${field.displayName}`
+        }));
+      }
+    }
+  }
+  return baseProperties;
+}
+function getEventPayloadProperties(actionType, eventName, sourceBlockInputs) {
+  if (!actionType || !eventName) return [];
+  const actionDef = getAction(actionType);
+  const events = getEventsForBlock(actionDef, sourceBlockInputs);
+  const event = events.find((e) => e.name === eventName);
+  if (!event) return [];
+  return event.payloadSchema.map((field) => ({
+    name: `payload.${field.path}`,
+    displayName: field.displayName,
+    type: narrowFieldType(field.type),
+    description: field.description || `Event payload field: ${field.displayName}`
+  }));
+}
+function narrowFieldType(type) {
+  switch (type) {
+    case "string":
+    case "number":
+    case "boolean":
+    case "object":
+    case "array":
+      return type;
+    default:
+      return "string";
+  }
+}
+function getPropertyByName(blockType, propertyName) {
+  const properties = getConditionableProperties(blockType);
+  return properties.find((prop) => prop.name === propertyName) || null;
+}
+
+// src/mantine/components/DataInput/BlockPropSelector.tsx
+var TRIGGER_PAYLOAD_BLOCK_ID = "__trigger__";
+var ITEM_SCOPE_BLOCK_ID = "item";
+function buildPropertyTree(properties) {
+  const root = [];
+  properties.forEach((prop) => {
+    const pathParts = prop.name.split(".");
+    let currentLevel = root;
+    pathParts.forEach((part, index) => {
+      const isLastPart = index === pathParts.length - 1;
+      const fullPath = pathParts.slice(0, index + 1).join(".");
+      let existingNode = currentLevel.find((node) => node.name === part);
+      if (!existingNode) {
+        const newNode = {
+          name: part,
+          displayName: isLastPart ? prop.displayName : part,
+          type: isLastPart ? prop.type : "object",
+          fullPath,
+          children: [],
+          isLeaf: isLastPart
+        };
+        currentLevel.push(newNode);
+        existingNode = newNode;
+      }
+      if (!isLastPart) {
+        currentLevel = existingNode.children;
+      }
+    });
+  });
+  return root;
+}
+function getBlockDisplayName(block) {
+  const title = block.props?.title || block.props?.name || block.props?.label;
+  if (title) return title;
+  return `${block.type} (${block.id.slice(0, 8)}...)`;
+}
+function getBlockTypeColor(blockType) {
+  const colorMap = {
+    checkbox: "blue",
+    proposal: "green",
+    proposalVote: "teal",
+    list: "orange",
+    overview: "violet",
+    proposalActions: "pink",
+    apiRequest: "cyan",
+    action: "teal",
+    email: "indigo",
+    claim: "yellow",
+    bid: "orange",
+    evaluator: "grape"
+  };
+  return colorMap[blockType] || "gray";
+}
+var DROPDOWN_BG = "var(--mantine-color-neutralColor-2)";
+var ITEM_HOVER_BG = "var(--mantine-color-neutralColor-3)";
+var BORDER_COLOR = "var(--mantine-color-neutralColor-5)";
+var TEXT_PRIMARY = "var(--mantine-color-text)";
+var TEXT_DIMMED = "var(--mantine-color-dimmed)";
+function BlockPropSelector({ children, opened, onClose, onSelect, editorDocument, currentBlockId, triggerSource, itemScope }) {
+  const [searchQuery, setSearchQuery] = useState("");
+  const [selectedBlock, setSelectedBlock] = useState(null);
+  const [navigationPath, setNavigationPath] = useState([]);
+  const triggerVirtualBlock = useMemo(() => {
+    if (!triggerSource) return null;
+    const properties = getEventPayloadProperties(triggerSource.sourceActionType, triggerSource.eventName, triggerSource.sourceBlockInputs);
+    if (properties.length === 0) return null;
+    const sourceLabel = triggerSource.sourceDisplayName || triggerSource.sourceBlockId;
+    return {
+      id: TRIGGER_PAYLOAD_BLOCK_ID,
+      type: "trigger",
+      displayName: `On ${triggerSource.eventName} from ${sourceLabel}`,
+      properties,
+      propertyTree: buildPropertyTree(properties)
+    };
+  }, [triggerSource]);
+  const itemVirtualBlock = useMemo(() => {
+    if (!itemScope || !itemScope.schema || itemScope.schema.length === 0) return null;
+    const properties = itemScope.schema.map((f) => ({
+      name: f.path,
+      displayName: f.displayName || f.path,
+      type: ["string", "number", "boolean", "object", "array"].includes(f.type) ? f.type : "string",
+      description: f.description
+    }));
+    return {
+      id: ITEM_SCOPE_BLOCK_ID,
+      type: "item",
+      displayName: itemScope.displayName || "Current line item",
+      properties,
+      propertyTree: buildPropertyTree(properties)
+    };
+  }, [itemScope]);
+  const availableBlocks = useMemo(() => {
+    if (!editorDocument) return [];
+    const regularBlocks = editorDocument.filter((block) => {
+      if (currentBlockId && block.id === currentBlockId) return false;
+      return getConditionableProperties(block.type, block).length > 0;
+    }).map((block) => ({
+      ...block,
+      displayName: getBlockDisplayName(block),
+      properties: getConditionableProperties(block.type, block),
+      propertyTree: buildPropertyTree(getConditionableProperties(block.type, block))
+    }));
+    const virtuals = [];
+    if (itemVirtualBlock) virtuals.push(itemVirtualBlock);
+    if (triggerVirtualBlock) virtuals.push(triggerVirtualBlock);
+    return [...virtuals, ...regularBlocks];
+  }, [editorDocument, currentBlockId, triggerVirtualBlock, itemVirtualBlock]);
+  const filteredBlocks = useMemo(() => {
+    if (!searchQuery.trim()) return availableBlocks;
+    const query = searchQuery.toLowerCase();
+    return availableBlocks.filter((block) => {
+      if (block.displayName.toLowerCase().includes(query)) return true;
+      if (block.type.toLowerCase().includes(query)) return true;
+      return block.properties.some((prop) => prop.name.toLowerCase().includes(query) || prop.displayName.toLowerCase().includes(query));
+    });
+  }, [availableBlocks, searchQuery]);
+  const currentNodes = useMemo(() => {
+    if (!selectedBlock) return [];
+    if (navigationPath.length === 0) return selectedBlock.propertyTree;
+    return navigationPath[navigationPath.length - 1].children;
+  }, [selectedBlock, navigationPath]);
+  const handleBlockSelect = (block) => {
+    setSelectedBlock(block);
+    setNavigationPath([]);
+    setSearchQuery("");
+  };
+  const handleNodeClick = (node) => {
+    if (node.isLeaf) {
+      onSelect({
+        blockId: selectedBlock.id,
+        blockType: selectedBlock.type,
+        propName: node.fullPath,
+        propDisplayName: node.displayName
+      });
+      handleClose();
+    } else {
+      setNavigationPath([...navigationPath, node]);
+    }
+  };
+  const handleBack = () => {
+    if (navigationPath.length > 0) {
+      setNavigationPath(navigationPath.slice(0, -1));
+    } else {
+      setSelectedBlock(null);
+    }
+  };
+  const handleClose = () => {
+    setSelectedBlock(null);
+    setNavigationPath([]);
+    setSearchQuery("");
+    onClose();
+  };
+  const headerTitle = !selectedBlock ? "Select a Block" : navigationPath.length === 0 ? selectedBlock.displayName : navigationPath[navigationPath.length - 1].displayName;
+  const headerSubtitle = !selectedBlock ? null : navigationPath.length === 0 ? "Select a property" : null;
+  return /* @__PURE__ */ React.createElement(Popover, { opened, onClose: handleClose, position: "bottom-end", width: 360, withinPortal: true }, /* @__PURE__ */ React.createElement(Popover.Target, null, children), /* @__PURE__ */ React.createElement(
+    Popover.Dropdown,
+    {
+      p: 0,
+      style: {
+        backgroundColor: DROPDOWN_BG,
+        border: `1px solid ${BORDER_COLOR}`,
+        borderRadius: 10,
+        overflow: "hidden"
+      }
+    },
+    /* @__PURE__ */ React.createElement(
+      Box,
+      {
+        px: "md",
+        py: "sm",
+        style: {
+          borderBottom: `1px solid ${BORDER_COLOR}`,
+          backgroundColor: "#282828"
+        }
+      },
+      /* @__PURE__ */ React.createElement(Group, { justify: "space-between", align: "center" }, /* @__PURE__ */ React.createElement(Group, { gap: 6 }, (selectedBlock || navigationPath.length > 0) && /* @__PURE__ */ React.createElement(ActionIcon, { variant: "subtle", size: "sm", onClick: handleBack, color: "gray", styles: { root: { color: TEXT_DIMMED, "&:hover": { backgroundColor: ITEM_HOVER_BG } } } }, /* @__PURE__ */ React.createElement(IconArrowLeft, { size: 14 })), /* @__PURE__ */ React.createElement(Stack, { gap: 0 }, /* @__PURE__ */ React.createElement(Text, { size: "sm", fw: 500, c: TEXT_PRIMARY, style: { letterSpacing: "0.2px" } }, headerTitle), headerSubtitle && /* @__PURE__ */ React.createElement(Text, { size: "xs", c: TEXT_DIMMED }, headerSubtitle))), /* @__PURE__ */ React.createElement(ActionIcon, { variant: "subtle", size: "sm", onClick: handleClose, styles: { root: { color: TEXT_DIMMED, "&:hover": { backgroundColor: ITEM_HOVER_BG } } } }, /* @__PURE__ */ React.createElement(IconX, { size: 14 })))
+    ),
+    !selectedBlock && /* @__PURE__ */ React.createElement(Box, { px: "md", py: "xs", style: { borderBottom: `1px solid ${BORDER_COLOR}` } }, /* @__PURE__ */ React.createElement(
+      TextInput,
+      {
+        placeholder: "Search blocks...",
+        leftSection: /* @__PURE__ */ React.createElement(IconSearch, { size: 14, color: TEXT_DIMMED }),
+        value: searchQuery,
+        onChange: (e) => setSearchQuery(e.currentTarget.value),
+        size: "xs",
+        rightSection: searchQuery ? /* @__PURE__ */ React.createElement(ActionIcon, { variant: "subtle", size: "xs", onClick: () => setSearchQuery(""), styles: { root: { color: TEXT_DIMMED } } }, /* @__PURE__ */ React.createElement(IconX, { size: 12 })) : null,
+        styles: {
+          input: {
+            backgroundColor: "var(--mantine-color-neutralColor-3)",
+            border: `1px solid ${BORDER_COLOR}`,
+            color: TEXT_PRIMARY,
+            "&::placeholder": { color: TEXT_DIMMED },
+            "&:focus": { borderColor: "var(--mantine-color-accent-5)" }
+          }
+        }
+      }
+    )),
+    /* @__PURE__ */ React.createElement(ScrollArea, { h: 280, type: "auto", scrollbarSize: 4, styles: { scrollbar: { '&[data-orientation="vertical"] .mantine-ScrollArea-thumb': { backgroundColor: BORDER_COLOR } } } }, /* @__PURE__ */ React.createElement(Box, { p: "xs" }, !selectedBlock ? filteredBlocks.length === 0 ? /* @__PURE__ */ React.createElement(Text, { c: TEXT_DIMMED, ta: "center", py: "xl", size: "sm" }, availableBlocks.length === 0 ? "No referenceable blocks found" : "No blocks match your search") : /* @__PURE__ */ React.createElement(Stack, { gap: 4 }, filteredBlocks.map((block) => /* @__PURE__ */ React.createElement(
+      Box,
+      {
+        key: block.id,
+        onClick: () => handleBlockSelect(block),
+        style: {
+          borderRadius: 6,
+          border: `1px solid ${BORDER_COLOR}`,
+          padding: "10px 12px",
+          cursor: "pointer",
+          transition: "background-color 0.1s ease, border-color 0.1s ease",
+          backgroundColor: "transparent"
+        },
+        onMouseEnter: (e) => {
+          e.currentTarget.style.backgroundColor = ITEM_HOVER_BG;
+          e.currentTarget.style.borderColor = "#555";
+        },
+        onMouseLeave: (e) => {
+          e.currentTarget.style.backgroundColor = "transparent";
+          e.currentTarget.style.borderColor = BORDER_COLOR;
+        }
+      },
+      /* @__PURE__ */ React.createElement(Group, { gap: "xs", justify: "space-between" }, /* @__PURE__ */ React.createElement(Group, { gap: 8 }, /* @__PURE__ */ React.createElement(IconBolt, { size: 14, color: `var(--mantine-color-${getBlockTypeColor(block.type)}-5)` }), /* @__PURE__ */ React.createElement(Text, { fw: 500, size: "sm", c: TEXT_PRIMARY }, block.displayName), /* @__PURE__ */ React.createElement(Badge, { size: "xs", variant: "light", color: getBlockTypeColor(block.type), style: { textTransform: "none" } }, block.type)), /* @__PURE__ */ React.createElement(IconChevronRight, { size: 14, color: TEXT_DIMMED }))
+    ))) : currentNodes.length === 0 ? /* @__PURE__ */ React.createElement(Text, { c: TEXT_DIMMED, ta: "center", py: "xl", size: "sm" }, "No properties available") : /* @__PURE__ */ React.createElement(Stack, { gap: 2 }, currentNodes.map((node, index) => /* @__PURE__ */ React.createElement(
+      Box,
+      {
+        key: index,
+        onClick: () => handleNodeClick(node),
+        style: {
+          padding: "9px 12px",
+          borderRadius: 6,
+          cursor: "pointer",
+          transition: "background-color 0.1s ease",
+          backgroundColor: "transparent"
+        },
+        onMouseEnter: (e) => e.currentTarget.style.backgroundColor = ITEM_HOVER_BG,
+        onMouseLeave: (e) => e.currentTarget.style.backgroundColor = "transparent"
+      },
+      /* @__PURE__ */ React.createElement(Group, { gap: "xs", justify: "space-between" }, /* @__PURE__ */ React.createElement(Group, { gap: 8 }, /* @__PURE__ */ React.createElement(Text, { size: "sm", c: node.isLeaf ? TEXT_PRIMARY : TEXT_DIMMED }, node.displayName), /* @__PURE__ */ React.createElement(Badge, { size: "xs", variant: "outline", color: "gray", style: { borderColor: BORDER_COLOR, color: TEXT_DIMMED, textTransform: "none" } }, node.type)), !node.isLeaf && /* @__PURE__ */ React.createElement(IconChevronRight, { size: 14, color: TEXT_DIMMED }))
+    )))))
+  ));
+}
+
+// src/mantine/components/DataInput/DataInput.tsx
+function DataInput({
+  value,
+  onChange,
+  placeholder,
+  editorDocument,
+  currentBlockId,
+  leftSection,
+  leftSectionWidth,
+  disabled = false,
+  description,
+  label,
+  required,
+  size = "sm",
+  itemScope
+}) {
+  const [selectorOpened, setSelectorOpened] = useState2(false);
+  const containsReferences = useMemo2(() => hasReferences(value), [value]);
+  const references = useMemo2(() => parseReferences(value || ""), [value]);
+  const handleOpenSelector = useCallback(() => setSelectorOpened(true), []);
+  const handleCloseSelector = useCallback(() => setSelectorOpened(false), []);
+  const handleSelectProperty = useCallback(
+    (selection) => {
+      const reference = createReference(selection.blockId, selection.propName);
+      onChange(value ? `${value}${reference}` : reference);
+    },
+    [value, onChange]
+  );
+  const handleClearReferences = useCallback(() => {
+    let newValue = value || "";
+    references.forEach((ref) => {
+      newValue = newValue.replace(ref.fullMatch, "");
+    });
+    onChange(newValue);
+  }, [value, references, onChange]);
+  return /* @__PURE__ */ React2.createElement(
+    Input.Wrapper,
+    {
+      label,
+      description,
+      required,
+      size,
+      style: { width: "100%" },
+      styles: {
+        label: { color: "var(--mantine-color-dimmed)" },
+        description: { color: "var(--mantine-color-dimmed)" }
+      }
+    },
+    /* @__PURE__ */ React2.createElement(
+      Input,
+      {
+        value: value || "",
+        onChange: (e) => onChange(e.currentTarget.value),
+        placeholder,
+        leftSection,
+        leftSectionWidth,
+        disabled,
+        size,
+        radius: "md",
+        style: { width: "100%" },
+        styles: {
+          input: {
+            background: "var(--mantine-color-neutralColor-2)",
+            borderColor: "var(--mantine-color-neutralColor-5)",
+            color: "var(--mantine-color-text)",
+            "&:focus": {
+              borderColor: "var(--mantine-color-accent-5)"
+            }
+          }
+        },
+        rightSectionPointerEvents: "all",
+        rightSectionWidth: containsReferences ? 52 : 28,
+        rightSection: /* @__PURE__ */ React2.createElement(Group2, { gap: 2, wrap: "nowrap" }, containsReferences && /* @__PURE__ */ React2.createElement(Tooltip, { label: "Clear references", position: "top" }, /* @__PURE__ */ React2.createElement(ActionIcon2, { variant: "subtle", color: "gray", onClick: handleClearReferences, size: "xs" }, /* @__PURE__ */ React2.createElement(IconX2, { size: 12 }))), /* @__PURE__ */ React2.createElement(
+          BlockPropSelector,
+          {
+            opened: selectorOpened,
+            onClose: handleCloseSelector,
+            onSelect: handleSelectProperty,
+            editorDocument,
+            currentBlockId,
+            itemScope
+          },
+          /* @__PURE__ */ React2.createElement(Tooltip, { label: containsReferences ? "Add another reference" : "Insert block reference", position: "top" }, /* @__PURE__ */ React2.createElement(ActionIcon2, { variant: "subtle", color: containsReferences ? "teal" : "gray", onClick: handleOpenSelector, disabled, size: "xs" }, /* @__PURE__ */ React2.createElement(IconVariable, { size: 14 })))
+        ))
+      }
+    )
+  );
+}
+
+export {
+  parseResponseSchema,
+  validateResponseAgainstSchema,
+  getConditionableProperties,
+  getPropertyByName,
+  DataInput
+};
+//# sourceMappingURL=chunk-4PONO4US.js.map