@retailcrm/embed-ui-v1-components 0.9.21 → 0.9.22-alpha.1

package/dist/remote.cjs

@@ -124,13 +124,13 @@ const UiError = remote.defineRemoteComponent(
   UiErrorType,
   ["click", "focus", "blur"]
 );
-const _hoisted_1$7 = {
+const _hoisted_1$9 = {
   xmlns: "http://www.w3.org/2000/svg",
   fill: "currentColor",
   viewBox: "0 0 24 24"
 };
-function render$2(_ctx, _cache) {
-  return vue.openBlock(), vue.createElementBlock("svg", _hoisted_1$7, [..._cache[0] || (_cache[0] = [
+function render$3(_ctx, _cache) {
+  return vue.openBlock(), vue.createElementBlock("svg", _hoisted_1$9, [..._cache[0] || (_cache[0] = [
     vue.createElementVNode("path", {
       "fill-rule": "evenodd",
       d: "M12 2C6.477 2 2 6.477 2 12s4.477 10 10 10 10-4.477 10-10A10 10 0 0 0 12 2m1 15.5a.5.5 0 0 1-.5.5h-1a.5.5 0 0 1-.5-.5v-1a.5.5 0 0 1 .5-.5h1a.5.5 0 0 1 .5.5zm.88-5.21a2.89 2.89 0 0 0 2-2.73V9A2.88 2.88 0 0 0 13 6.12h-2A2.88 2.88 0 0 0 8.12 9v.5a.5.5 0 0 0 .5.5h.76a.5.5 0 0 0 .5-.5V9c0-.619.501-1.12 1.12-1.12h2A1.12 1.12 0 0 1 14.16 9v.56a1.13 1.13 0 0 1-.76 1.07l-.95.31a1.88 1.88 0 0 0-1.29 1.78v.78a.5.5 0 0 0 .5.5h.76a.5.5 0 0 0 .5-.5v-.78c0-.053.032-.1.08-.12z",
@@ -138,18 +138,28 @@ function render$2(_ctx, _cache) {
     }, null, -1)
   ])]);
 }
-const IconHelp = { render: render$2 };
+const IconHelp = { render: render$3 };
 const UiPopperType = "UiPopper";
-const UiPopper = remote.defineRemoteComponent(UiPopperType);
+const UiPopper = remote.defineRemoteComponent(UiPopperType, {
+  emits: [
+    "attached",
+    "dispose",
+    "hide",
+    "hidden",
+    "show",
+    "shown",
+    "update:visible"
+  ]
+});
 const UiPopperConnectorType = "UiPopperConnector";
 const UiPopperConnector = remote.defineRemoteComponent(UiPopperConnectorType);
 const UiPopperTargetType = "UiPopperTarget";
 const UiPopperTarget = remote.defineRemoteComponent(UiPopperTargetType);
 const UiTooltipType = "UiTooltip";
 const UiTooltip = remote.defineRemoteComponent(UiTooltipType);
-const _hoisted_1$6 = { class: "ui-v1-field__headline" };
-const _hoisted_2$3 = ["id", "for"];
-const _hoisted_3$3 = {
+const _hoisted_1$8 = { class: "ui-v1-field__headline" };
+const _hoisted_2$4 = ["id", "for"];
+const _hoisted_3$4 = {
   key: 0,
   class: "ui-v1-field__required-mark",
   "aria-hidden": "true"
@@ -163,7 +173,7 @@ const _hoisted_5$1 = {
   class: "ui-v1-field__addon"
 };
 const _hoisted_6 = { class: "ui-v1-field__control" };
-const _sfc_main$b = /* @__PURE__ */ vue.defineComponent({
+const _sfc_main$e = /* @__PURE__ */ vue.defineComponent({
   ...{
     inheritAttrs: false
   },
@@ -221,7 +231,7 @@ const _sfc_main$b = /* @__PURE__ */ vue.defineComponent({
           "ui-v1-field_readonly": __props.readonly
         }
       }, _ctx.$attrs), [
-        vue.createElementVNode("div", _hoisted_1$6, [
+        vue.createElementVNode("div", _hoisted_1$8, [
           __props.label || _ctx.$slots.label ? (vue.openBlock(), vue.createElementBlock("label", {
             key: 0,
             id: `${__props.id}-label`,
@@ -231,8 +241,8 @@ const _sfc_main$b = /* @__PURE__ */ vue.defineComponent({
             vue.renderSlot(_ctx.$slots, "label", {}, () => [
               vue.createTextVNode(vue.toDisplayString(__props.label), 1)
             ]),
-            __props.required ? (vue.openBlock(), vue.createElementBlock("span", _hoisted_3$3, " * ")) : vue.createCommentVNode("", true)
-          ], 8, _hoisted_2$3)) : vue.createCommentVNode("", true),
+            __props.required ? (vue.openBlock(), vue.createElementBlock("span", _hoisted_3$4, " * ")) : vue.createCommentVNode("", true)
+          ], 8, _hoisted_2$4)) : vue.createCommentVNode("", true),
           __props.hint || _ctx.$slots.hint ? (vue.openBlock(), vue.createElementBlock("span", _hoisted_4$2, [
             vue.createVNode(vue.unref(UiPopperConnector), null, {
               default: vue.withCtx(() => [
@@ -317,6 +327,954 @@ const UiLoader = remote.defineRemoteComponent(
   UiLoaderType,
   ["click", "focus", "blur"]
 );
+var LogicTreeNodeKind = /* @__PURE__ */ ((LogicTreeNodeKind2) => {
+  LogicTreeNodeKind2["BRANCH"] = "branch";
+  LogicTreeNodeKind2["CONDITION"] = "condition";
+  LogicTreeNodeKind2["GROUP"] = "group";
+  return LogicTreeNodeKind2;
+})(LogicTreeNodeKind || {});
+var LogicTreeChildrenView = /* @__PURE__ */ ((LogicTreeChildrenView2) => {
+  LogicTreeChildrenView2["GROUPED"] = "grouped";
+  LogicTreeChildrenView2["PLAIN"] = "plain";
+  return LogicTreeChildrenView2;
+})(LogicTreeChildrenView || {});
+var LogicTreeConjunction = /* @__PURE__ */ ((LogicTreeConjunction2) => {
+  LogicTreeConjunction2["AND"] = "and";
+  LogicTreeConjunction2["OR"] = "or";
+  return LogicTreeConjunction2;
+})(LogicTreeConjunction || {});
+var LogicTreeNodeView = /* @__PURE__ */ ((LogicTreeNodeView2) => {
+  LogicTreeNodeView2["ACTIONS"] = "actions";
+  LogicTreeNodeView2["SUMMARY"] = "summary";
+  return LogicTreeNodeView2;
+})(LogicTreeNodeView || {});
+var LogicTreeTone = /* @__PURE__ */ ((LogicTreeTone2) => {
+  LogicTreeTone2["BLUE"] = "blue";
+  LogicTreeTone2["GREEN"] = "green";
+  LogicTreeTone2["GREY"] = "grey";
+  LogicTreeTone2["RED"] = "red";
+  LogicTreeTone2["YELLOW"] = "yellow";
+  return LogicTreeTone2;
+})(LogicTreeTone || {});
+const pluralization_en_GB = (choice) => choice === 1 ? 0 : 1;
+const pluralization_es_ES = (choice) => choice === 1 ? 0 : 1;
+const pluralization_ru_RU = (choice, choicesLength) => {
+  if (choicesLength === 2) {
+    return choice === 1 ? 0 : 1;
+  }
+  const mod100 = choice % 100;
+  return mod100 % 10 === 1 && mod100 !== 11 ? 0 : mod100 % 10 >= 2 && mod100 % 10 <= 4 && !(mod100 >= 10 && mod100 < 15) ? 1 : 2;
+};
+const get = (messages, path) => {
+  let i = 0;
+  let slice = messages[path[0]];
+  while (i < path.length) {
+    if (typeof slice === "string" && i + 1 === path.length) {
+      return slice;
+    }
+    if (typeof slice !== "object") {
+      return void 0;
+    }
+    slice = slice[path[++i]];
+  }
+  return slice;
+};
+const replace = (message, values) => {
+  return Object.keys(values).reduce((message2, key) => {
+    const pattern = new RegExp(`\\{${key}\\}`, "g");
+    const replacement = String(values[key]);
+    return message2.replace(pattern, replacement);
+  }, message);
+};
+const compile = (messages, path, values = void 0) => {
+  const message = get(messages, path);
+  if (typeof message === "string" && values) {
+    return replace(message, values);
+  }
+  return message;
+};
+const fail = (message) => {
+  throw new Error(message);
+};
+const t = (locale2, messages, path, values = void 0) => {
+  const keys = path.split(".");
+  if (locale2) {
+    const message = compile(messages[locale2] ?? {}, keys, values);
+    return typeof message !== "object" ? message : fail(`Translation for "${locale2}:${path}" is not translatable`);
+  }
+  return void 0;
+};
+const plural = (template, choice, rule) => {
+  const forms = template.split("|");
+  return forms[rule(choice, forms.length)];
+};
+class I18n {
+  parent;
+  messages;
+  computed;
+  pluralization;
+  fallback;
+  constructor(options = void 0, parent = void 0) {
+    this.parent = parent;
+    this.messages = options?.messages ?? {};
+    this.computed = options?.computed ?? {};
+    this.pluralization = {
+      "en-GB": pluralization_en_GB,
+      "es-ES": pluralization_es_ES,
+      "ru-RU": pluralization_ru_RU,
+      ...options?.pluralization ?? {}
+    };
+    this.fallback = options?.fallback;
+  }
+  t(locale2, path, values = void 0) {
+    try {
+      const _t = (locale22) => t(locale22, this.messages, path, values);
+      return _t(locale2) ?? _t(this.fallback) ?? fail(`Translation for "${path}" does not exists`);
+    } catch (e) {
+      if (this.parent) {
+        return this.parent.t(locale2, path, values);
+      }
+      throw e;
+    }
+  }
+  tc(locale2, path, choice, values = void 0) {
+    return plural(
+      this.t(
+        locale2,
+        path,
+        values
+      ),
+      choice,
+      this.pluralization[locale2]
+    );
+  }
+  compute(locale2, key, values) {
+    const computed = this.computed[key];
+    if (computed) {
+      return computed(localize(this, locale2), values);
+    }
+    if (this.parent) {
+      return this.parent.compute(locale2, key, values);
+    }
+    return fail("Key " + key + " is not registered");
+  }
+  extend(options) {
+    return new I18n({
+      pluralization: this.pluralization,
+      fallback: this.fallback,
+      ...options
+    }, this);
+  }
+}
+const localize = (i18n, locale2) => ({
+  t(path, values = void 0) {
+    return i18n.t(locale2, path, values);
+  },
+  tc(path, choice, values = void 0) {
+    return i18n.tc(locale2, path, choice, values);
+  },
+  compute(key, values) {
+    return i18n.compute(locale2, key, values);
+  }
+});
+const fallback = "en-GB";
+const define = (options = void 0, parent = void 0) => {
+  const i18n = new I18n({
+    ...options,
+    fallback
+  }, parent);
+  const extend = (i18n2, options2 = void 0) => options2 ? i18n2.extend(options2) : i18n2;
+  return {
+    i18n,
+    init: (locale2, options2 = void 0) => localize(
+      extend(i18n, options2),
+      locale2
+    ),
+    fallback
+  };
+};
+const relationAnd$2 = "AND";
+const relationOr$2 = "OR";
+const messages_en_GB$1 = {
+  "delete": "Delete",
+  relationAnd: relationAnd$2,
+  relationOr: relationOr$2
+};
+const relationAnd$1 = "Y";
+const relationOr$1 = "O";
+const messages_es_ES$1 = {
+  "delete": "Eliminar",
+  relationAnd: relationAnd$1,
+  relationOr: relationOr$1
+};
+const relationAnd = "И";
+const relationOr = "ИЛИ";
+const messages_ru_RU$1 = {
+  "delete": "Удалить",
+  relationAnd,
+  relationOr
+};
+const _i18n = define({
+  messages: {
+    "en-GB": messages_en_GB$1,
+    "es-ES": messages_es_ES$1,
+    "ru-RU": messages_ru_RU$1
+  }
+});
+const I18nInjectKey = /* @__PURE__ */ Symbol("$embedI18n");
+const UiLogicTreeRootType = "UiLogicTreeRoot";
+const UiLogicTreeRoot = remote.defineRemoteComponent(UiLogicTreeRootType, {
+  emits: [
+    "outsideClick"
+  ],
+  slots: ["default"]
+});
+const UiLogicTreeNodeType = "UiLogicTreeNode";
+const UiLogicTreeNode = remote.defineRemoteComponent(UiLogicTreeNodeType, {
+  emits: [
+    "nodeClick",
+    "nodeEdit"
+  ],
+  slots: ["conjunction-poppers", "prefix", "content", "trailing"]
+});
+const UiLogicTreeCaretType = "UiLogicTreeCaret";
+const UiLogicTreeCaret = remote.defineRemoteComponent(UiLogicTreeCaretType);
+const UiLogicTreeNodeItemType = "UiLogicTreeNodeItem";
+const UiLogicTreeNodeItem = remote.defineRemoteComponent(UiLogicTreeNodeItemType, {
+  slots: ["default", "headline", "title", "trailing"]
+});
+const UiLogicTreeNodeIconType = "UiLogicTreeNodeIcon";
+const UiLogicTreeNodeIcon = remote.defineRemoteComponent(UiLogicTreeNodeIconType, {
+  slots: ["default"]
+});
+const _hoisted_1$7 = { class: "ui-v1-logic-tree__slot-content" };
+const _hoisted_2$3 = { class: "ui-v1-logic-tree__slot-content" };
+const _hoisted_3$3 = { class: "ui-v1-logic-tree__slot-content" };
+const _sfc_main$d = /* @__PURE__ */ vue.defineComponent({
+  __name: "UiLogicTree",
+  props: {
+    items: { default: () => [] }
+  },
+  emits: ["action", "control-action", "control:update", "drop", "remove", "node:add", "node:edit", "node:remove", "toggle", "update:items"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const i18n = vue.computed(() => _i18n.init(vue.inject(I18nInjectKey, null)?.locale ?? _i18n.fallback));
+    const resolveConjunctionLabel = (conjunction) => {
+      if (conjunction === LogicTreeConjunction.AND) {
+        return i18n.value.t("relationAnd");
+      }
+      if (conjunction === LogicTreeConjunction.OR) {
+        return i18n.value.t("relationOr");
+      }
+      return String(conjunction ?? "");
+    };
+    const itemsState = vue.shallowRef([]);
+    const activePathKey = vue.ref("");
+    const fallbackTone = (node) => node.tone ?? (node.kind === LogicTreeNodeKind.GROUP ? LogicTreeTone.GREEN : LogicTreeTone.BLUE);
+    const resolveConjunctionTone = (conjunction, fallback2) => {
+      if (conjunction === LogicTreeConjunction.OR) {
+        return LogicTreeTone.YELLOW;
+      }
+      if (conjunction === LogicTreeConjunction.AND) {
+        return LogicTreeTone.BLUE;
+      }
+      return fallback2;
+    };
+    const resolveNodeConjunction = (node, index, isGroupedSectionNode, parentNode) => {
+      if (isGroupedSectionNode || !isConjunctionContentNode(node)) {
+        return "";
+      }
+      if (index === 0) {
+        return parentNode && isConjunctionContentNode(parentNode) && countConjunctionContentChildren(parentNode) >= 2 ? node.conjunction ?? "" : "";
+      }
+      return node.conjunction ?? "";
+    };
+    const resolveConjunctionOffset = (conjunction) => {
+      if (!conjunction) {
+        return void 0;
+      }
+      return -8;
+    };
+    const resolveSubtreeEndPathKey = (source, nodeIndex) => {
+      const nodeEntry = source[nodeIndex];
+      const nodePathKey = pathToKey(nodeEntry.path);
+      const subtreePrefix = `${nodePathKey}.`;
+      let endIndex = nodeIndex;
+      for (let index = nodeIndex + 1; index < source.length; index += 1) {
+        const candidatePathKey = pathToKey(source[index].path);
+        if (candidatePathKey.startsWith(subtreePrefix)) {
+          endIndex = index;
+          continue;
+        }
+        break;
+      }
+      return pathToKey(source[endIndex].path);
+    };
+    const resolveConjunctionRangeEndPathKey = (source, nodeIndex) => {
+      const nodeEntry = source[nodeIndex];
+      const siblingIndex = nodeEntry.path.at(-1);
+      if (siblingIndex === void 0) {
+        return void 0;
+      }
+      let lastSiblingNodeIndex = nodeIndex;
+      source.forEach((candidate, candidateIndex) => {
+        const candidateSiblingIndex = candidate.path.at(-1);
+        if (candidate.path.length === nodeEntry.path.length && candidateSiblingIndex !== void 0 && candidateSiblingIndex >= siblingIndex && candidate.parentPath.length === nodeEntry.parentPath.length && candidate.parentPath.every((segment, index) => segment === nodeEntry.parentPath[index])) {
+          lastSiblingNodeIndex = candidateIndex;
+        }
+      });
+      return resolveSubtreeEndPathKey(source, lastSiblingNodeIndex);
+    };
+    const applyConjunctionToneToConnectors = (connectors, conjunction, conjunctionTone) => {
+      if (!conjunction || connectors.length === 0) {
+        return connectors;
+      }
+      return connectors.map((connector, connectorIndex, source) => connectorIndex === source.length - 1 ? {
+        ...connector,
+        tone: conjunctionTone
+      } : connector);
+    };
+    const setConnectorToneAtIndex = (nodeEntry, connectorIndex, tone) => {
+      if (!nodeEntry.connectors[connectorIndex]) {
+        return nodeEntry;
+      }
+      return {
+        ...nodeEntry,
+        connectors: nodeEntry.connectors.map((connector, index) => index === connectorIndex ? {
+          ...connector,
+          tone
+        } : connector)
+      };
+    };
+    const applyConjunctionBranchTones = (source) => {
+      const nodes = source.map((nodeEntry) => ({
+        ...nodeEntry,
+        connectors: nodeEntry.connectors.map((connector) => ({ ...connector }))
+      }));
+      const startsWithPath = (path, prefix) => prefix.length <= path.length && prefix.every((segment, index) => path[index] === segment);
+      const recolorBranchLevel = (parentPath, connectorIndex, tone) => {
+        nodes.forEach((candidate, index) => {
+          if (!startsWithPath(candidate.path, parentPath)) {
+            return;
+          }
+          if (!candidate.connectors[connectorIndex]) {
+            return;
+          }
+          nodes[index] = setConnectorToneAtIndex(candidate, connectorIndex, tone);
+        });
+      };
+      nodes.forEach((nodeEntry) => {
+        if (!nodeEntry.conjunction) {
+          return;
+        }
+        const connectorIndex = Math.max(0, nodeEntry.connectors.length - 1);
+        recolorBranchLevel(nodeEntry.parentPath, connectorIndex, nodeEntry.conjunctionTone);
+      });
+      return nodes;
+    };
+    const applyConjunctionRanges = (source) => source.map((nodeEntry, nodeIndex) => {
+      if (!nodeEntry.conjunction) {
+        return nodeEntry;
+      }
+      const siblingIndex = nodeEntry.path.at(-1);
+      const parentPathKey = nodeEntry.parentPath.length > 0 ? pathToKey(nodeEntry.parentPath) : void 0;
+      const parentEntry = parentPathKey ? source.find((candidate) => pathToKey(candidate.path) === parentPathKey) : void 0;
+      if (siblingIndex === void 0) {
+        return nodeEntry;
+      }
+      if (siblingIndex === 0) {
+        return {
+          ...nodeEntry,
+          conjunctionEndPathKey: resolveConjunctionRangeEndPathKey(source, nodeIndex),
+          conjunctionStartPathKey: parentEntry ? pathToKey(parentEntry.path) : void 0
+        };
+      }
+      return {
+        ...nodeEntry,
+        conjunctionEndPathKey: resolveConjunctionRangeEndPathKey(source, nodeIndex),
+        conjunctionStartPathKey: pathToKey([...nodeEntry.parentPath, siblingIndex - 1])
+      };
+    });
+    const pathToKey = (path) => path.join(".");
+    const cloneNodes = (nodes) => nodes.map((node) => ({
+      ...node,
+      children: node.children ? cloneNodes(node.children) : void 0,
+      data: { ...node.data }
+    }));
+    const resolveConfiguredNodeView = (node) => node.data.view;
+    const isConjunctionContentNode = (node) => resolveConfiguredNodeView(node) !== LogicTreeNodeView.ACTIONS && node.kind !== LogicTreeNodeKind.BRANCH;
+    const countConjunctionContentChildren = (node) => node?.children?.filter((child) => isConjunctionContentNode(child)).length ?? 0;
+    const resolveNodeView = (nodeEntry) => {
+      const configuredNodeView = resolveConfiguredNodeView(nodeEntry.node);
+      if (configuredNodeView === LogicTreeNodeView.ACTIONS) {
+        return configuredNodeView;
+      }
+      return configuredNodeView;
+    };
+    const canToggleNode = (nodeEntry) => Boolean(nodeEntry.node.collapsible) && nodeEntry.hasChildren;
+    const canSetNodeEditable = (nodeEntry) => resolveConfiguredNodeView(nodeEntry.node) !== LogicTreeNodeView.ACTIONS && !canToggleNode(nodeEntry);
+    const isNodeEditing = (nodeEntry) => canSetNodeEditable(nodeEntry) && Boolean(nodeEntry.node.data.editable);
+    const setNodeEditable = (nodeEntry, value) => {
+      if (!canSetNodeEditable(nodeEntry)) {
+        return;
+      }
+      withItemsMutation((nextItems) => {
+        setEditableState(nextItems, value ? nodeEntry.path : null);
+      });
+    };
+    vue.watch(() => props.items, (items) => {
+      itemsState.value = cloneNodes(items ?? []);
+    }, { deep: true, immediate: true });
+    const withItemsMutation = (mutator) => {
+      const nextItems = cloneNodes(itemsState.value);
+      mutator(nextItems);
+      itemsState.value = nextItems;
+      emit("update:items", cloneNodes(itemsState.value));
+    };
+    const getBranchAtPath = (nodes, parentPath, create = false) => {
+      let branch = nodes;
+      for (const index of parentPath) {
+        const node = branch[index];
+        if (!node) {
+          return null;
+        }
+        if (!node.children) {
+          if (!create) {
+            return null;
+          }
+          node.children = [];
+        }
+        branch = node.children;
+      }
+      return branch;
+    };
+    const getNodeAtPath = (nodes, path) => {
+      const branch = getBranchAtPath(nodes, path.slice(0, -1));
+      const index = path.at(-1);
+      if (index === void 0) {
+        return null;
+      }
+      return branch?.[index] ?? null;
+    };
+    const setEditableState = (nodes, editablePath = null) => {
+      const editablePathKey = editablePath ? pathToKey(editablePath) : "";
+      const walk = (branch, parentPath = []) => {
+        branch.forEach((node, index) => {
+          const path = [...parentPath, index];
+          node.data.editable = editablePathKey !== "" && pathToKey(path) === editablePathKey;
+          if (node.children?.length) {
+            walk(node.children, path);
+          }
+        });
+      };
+      walk(nodes);
+    };
+    const resolveParentMeta = (nodes, path) => {
+      const parentPath = path.slice(0, -1);
+      const parentNode = parentPath.length > 0 ? getNodeAtPath(nodes, parentPath) : null;
+      return {
+        parentNode,
+        parentPath,
+        parentPathKey: parentPath.length > 0 ? pathToKey(parentPath) : null
+      };
+    };
+    const flatten = (nodes, ancestors = [], parentPath = [], parentTone = null, currentSectionKey = "", parentNode = null) => nodes.flatMap((node, index, siblings) => {
+      const isLast = index === siblings.length - 1;
+      const path = [...parentPath, index];
+      const expanded = node.expanded !== false;
+      const hasChildren = Boolean(node.children?.length);
+      const shouldPreserveChildLevel = node.kind === LogicTreeNodeKind.BRANCH && ancestors.length === 0;
+      const descendsIntoChildren = hasChildren && expanded;
+      const isGroupedSectionNode = Boolean(currentSectionKey);
+      const conjunction = resolveNodeConjunction(node, index, isGroupedSectionNode, parentNode);
+      const connectorTone = parentTone ?? fallbackTone(node);
+      const conjunctionTone = resolveConjunctionTone(conjunction, connectorTone);
+      const connectorContinues = !isLast || descendsIntoChildren;
+      const connectors = applyConjunctionToneToConnectors([
+        ...ancestors,
+        ...parentTone ? [{
+          continues: connectorContinues,
+          tone: connectorTone,
+          visible: true
+        }] : []
+      ].map((connector, connectorIndex, source) => ({
+        ...connector,
+        placeholder: isGroupedSectionNode && connectorIndex === source.length - 1
+      })), conjunction, conjunctionTone);
+      const conjunctionOffset = resolveConjunctionOffset(conjunction);
+      const flattenedNodes2 = [{
+        conjunction,
+        conjunctionEndPathKey: void 0,
+        conjunctionOffset,
+        conjunctionStartPathKey: void 0,
+        connectors,
+        expanded,
+        groupedPosition: "",
+        hasChildren,
+        node,
+        parentPath,
+        path,
+        conjunctionTone,
+        sectionKey: currentSectionKey
+      }];
+      if (hasChildren && expanded) {
+        const childAncestors = shouldPreserveChildLevel ? ancestors : [
+          ...ancestors,
+          ...parentTone ? [{
+            continues: connectorContinues,
+            tone: connectorTone,
+            visible: true
+          }] : []
+        ];
+        const childParentTone = shouldPreserveChildLevel ? parentTone ?? fallbackTone(node) : fallbackTone(node);
+        const nextSectionKey = node.childrenView === LogicTreeChildrenView.GROUPED ? pathToKey(path) : "";
+        flattenedNodes2.push(...flatten(
+          node.children ?? [],
+          childAncestors,
+          path,
+          childParentTone,
+          nextSectionKey,
+          node
+        ));
+      }
+      return flattenedNodes2;
+    });
+    const flattenedNodes = vue.computed(() => applyConjunctionRanges(applyConjunctionBranchTones(flatten(itemsState.value))));
+    const nodesWithGrouping = vue.computed(() => flattenedNodes.value.map((nodeEntry, index, source) => {
+      if (!nodeEntry.sectionKey) {
+        return nodeEntry;
+      }
+      const prev = source[index - 1];
+      const next = source[index + 1];
+      const hasPrev = prev?.sectionKey === nodeEntry.sectionKey;
+      const hasNext = next?.sectionKey === nodeEntry.sectionKey;
+      const parentNode = nodeEntry.parentPath.length > 0 ? getNodeAtPath(itemsState.value, nodeEntry.parentPath) : null;
+      const hasGroupedHeader = parentNode?.childrenView === LogicTreeChildrenView.GROUPED;
+      let groupedPosition = "single";
+      if (!hasPrev && hasNext) {
+        groupedPosition = "start";
+      } else if (hasPrev && hasNext) {
+        groupedPosition = "middle";
+      } else if (hasPrev && !hasNext) {
+        groupedPosition = "end";
+      } else if (!hasPrev && !hasNext && hasGroupedHeader) {
+        groupedPosition = "end";
+      }
+      return {
+        ...nodeEntry,
+        groupedPosition
+      };
+    }));
+    const renderEntries = vue.computed(() => {
+      const nextEntries = [];
+      for (let index = 0; index < nodesWithGrouping.value.length; index += 1) {
+        const nodeEntry = nodesWithGrouping.value[index];
+        if (!nodeEntry.sectionKey) {
+          nextEntries.push({
+            id: `node:${pathToKey(nodeEntry.path)}`,
+            kind: "node",
+            item: nodeEntry
+          });
+          continue;
+        }
+        const sectionNodes = [nodeEntry];
+        let cursor = index + 1;
+        while (nodesWithGrouping.value[cursor]?.sectionKey === nodeEntry.sectionKey) {
+          sectionNodes.push(nodesWithGrouping.value[cursor]);
+          cursor += 1;
+        }
+        nextEntries.push({
+          containerId: nodeEntry.sectionKey,
+          footerNodes: sectionNodes.filter((sectionNode) => resolveConfiguredNodeView(sectionNode.node) === LogicTreeNodeView.ACTIONS),
+          id: `group:${nodeEntry.sectionKey}`,
+          itemNodes: sectionNodes.filter((sectionNode) => resolveConfiguredNodeView(sectionNode.node) !== LogicTreeNodeView.ACTIONS),
+          kind: "grouped"
+        });
+        index = cursor - 1;
+      }
+      return nextEntries;
+    });
+    const isNodeDraggable = (node) => Boolean(node.data.draggable) && !node.data.disabled && resolveConfiguredNodeView(node) !== LogicTreeNodeView.ACTIONS;
+    const isGroupedDraggableNode = (nodeEntry) => Boolean(nodeEntry.sectionKey) && isNodeDraggable(nodeEntry.node);
+    const isNodeSelected = (nodeEntry) => Boolean(nodeEntry.node.data.selected) || activePathKey.value === pathToKey(nodeEntry.path) || isNodeEditing(nodeEntry);
+    const resolveNodeSlotProps = (nodeEntry) => ({
+      editing: isNodeEditing(nodeEntry),
+      expanded: nodeEntry.expanded,
+      grouped: Boolean(nodeEntry.sectionKey),
+      groupedHeader: nodeEntry.node.childrenView === LogicTreeChildrenView.GROUPED,
+      groupedPosition: nodeEntry.groupedPosition || void 0,
+      hasChildren: nodeEntry.hasChildren,
+      highlighted: Boolean(nodeEntry.node.data.highlighted),
+      disabled: Boolean(nodeEntry.node.data.disabled),
+      node: nodeEntry.node,
+      onAction: (actionId, kind) => {
+        onAction(nodeEntry, actionId, kind);
+      },
+      onControlAction: (controlId) => {
+        emit("control-action", {
+          controlId,
+          nodeId: nodeEntry.node.id
+        });
+      },
+      onControlUpdate: (controlId, value) => {
+        onControlUpdate(nodeEntry.path, controlId, value);
+      },
+      onRemove: () => {
+        onRemove(nodeEntry.path, nodeEntry.node.id);
+      },
+      onToggle: () => {
+        onToggle(nodeEntry);
+      },
+      path: [...nodeEntry.path],
+      pathKey: pathToKey(nodeEntry.path),
+      nodeView: resolveNodeView(nodeEntry),
+      selected: isNodeSelected(nodeEntry)
+    });
+    const onControlUpdate = (path, controlId, value) => {
+      const currentNode = getNodeAtPath(itemsState.value, path);
+      if (currentNode) {
+        emit("node:edit", {
+          controlId,
+          nodeId: currentNode.id,
+          pathKey: pathToKey(path),
+          value
+        });
+      }
+      emit("control:update", {
+        controlId,
+        nodeId: currentNode?.id ?? "",
+        value
+      });
+    };
+    const onToggle = (nodeEntry) => {
+      const nextExpanded = !nodeEntry.expanded;
+      withItemsMutation((nextItems) => {
+        const nextNode = getNodeAtPath(nextItems, nodeEntry.path);
+        if (nextNode) {
+          nextNode.expanded = nextExpanded;
+        }
+      });
+      emit("toggle", {
+        expanded: nextExpanded,
+        nodeId: nodeEntry.node.id
+      });
+    };
+    const onRemove = (path, nodeId) => {
+      const pathKey = pathToKey(path);
+      const index = path.at(-1);
+      const { parentNode, parentPathKey } = resolveParentMeta(itemsState.value, path);
+      if (activePathKey.value === pathKey) {
+        activePathKey.value = "";
+      }
+      if (index !== void 0) {
+        emit("node:remove", {
+          index,
+          nodeId,
+          parentNodeId: parentNode?.id ?? null,
+          parentPathKey,
+          pathKey
+        });
+      }
+      emit("remove", nodeId);
+    };
+    const onAction = (nodeEntry, actionId, kind) => {
+      if (resolveNodeView(nodeEntry) !== LogicTreeNodeView.ACTIONS) {
+        return;
+      }
+      const { parentNode, parentPathKey } = resolveParentMeta(itemsState.value, nodeEntry.path);
+      emit("node:add", {
+        actionId,
+        kind,
+        parentNodeId: parentNode?.id ?? null,
+        parentPathKey,
+        triggerNodeId: nodeEntry.node.id
+      });
+      emit("action", {
+        actionId,
+        nodeId: nodeEntry.node.id
+      });
+    };
+    const onNodeClick = (nodeEntry) => {
+      if (resolveNodeView(nodeEntry) === LogicTreeNodeView.ACTIONS) {
+        return;
+      }
+      if (canToggleNode(nodeEntry)) {
+        onToggle(nodeEntry);
+        activePathKey.value = pathToKey(nodeEntry.path);
+        return;
+      }
+      if (!canSetNodeEditable(nodeEntry)) {
+        withItemsMutation((nextItems) => {
+          setEditableState(nextItems, null);
+        });
+      }
+      activePathKey.value = pathToKey(nodeEntry.path);
+    };
+    const onOutsideClick = () => {
+      activePathKey.value = "";
+      withItemsMutation((nextItems) => {
+        setEditableState(nextItems, null);
+      });
+    };
+    const resolveGroupedDropPayload = (event) => {
+      if (!event.accepted || !event.targetContainerId || event.sourceContainerId !== event.targetContainerId || event.placement !== "before" && event.placement !== "after") {
+        return null;
+      }
+      return {
+        itemId: event.itemId,
+        payload: event.payload,
+        placement: event.placement,
+        sourceContainerId: event.sourceContainerId,
+        targetContainerId: event.targetContainerId,
+        targetIndex: event.targetIndex,
+        targetItemId: event.targetItemId
+      };
+    };
+    const onGroupedDrop = (event) => {
+      const payload = resolveGroupedDropPayload(event);
+      if (!payload) {
+        return;
+      }
+      const parentPath = payload.sourceContainerId.split(".").filter(Boolean).map((segment) => Number(segment));
+      withItemsMutation((nextItems) => {
+        const branchNode = getNodeAtPath(nextItems, parentPath);
+        const children = branchNode?.children;
+        if (!children?.length) {
+          return;
+        }
+        const sortableChildren = children.filter((child) => resolveConfiguredNodeView(child) !== LogicTreeNodeView.ACTIONS);
+        const footerChildren = children.filter((child) => resolveConfiguredNodeView(child) === LogicTreeNodeView.ACTIONS);
+        const movedNodeIndex = sortableChildren.findIndex((child) => child.id === payload.itemId);
+        if (movedNodeIndex === -1) {
+          return;
+        }
+        const [movedNode] = sortableChildren.splice(movedNodeIndex, 1);
+        if (!movedNode) {
+          return;
+        }
+        const targetIndex = Math.min(
+          Math.max(payload.targetIndex ?? sortableChildren.length, 0),
+          sortableChildren.length
+        );
+        sortableChildren.splice(targetIndex, 0, movedNode);
+        branchNode.children = [...sortableChildren, ...footerChildren];
+      });
+      emit("drop", payload);
+    };
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createBlock(vue.unref(UiLogicTreeRoot), { onOutsideClick }, {
+        default: vue.withCtx(() => [
+          (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(renderEntries.value, (entry) => {
+            return vue.openBlock(), vue.createElementBlock(vue.Fragment, {
+              key: entry.id
+            }, [
+              entry.kind === "grouped" ? (vue.openBlock(), vue.createBlock(vue.unref(remote.RemoteSortableContainer), {
+                key: 0,
+                as: "div",
+                class: "ui-v1-logic-tree__grouped-sortable",
+                "container-id": entry.containerId,
+                accepts: [entry.containerId],
+                "on-drop": onGroupedDrop
+              }, {
+                default: vue.withCtx(() => [
+                  (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(entry.itemNodes, (nodeEntry, index) => {
+                    return vue.openBlock(), vue.createBlock(vue.unref(remote.RemoteSortableItem), {
+                      key: nodeEntry.node.id,
+                      as: "div",
+                      class: "ui-v1-logic-tree__grouped-sortable-item",
+                      "item-id": nodeEntry.node.id,
+                      "container-id": entry.containerId,
+                      type: entry.containerId,
+                      index,
+                      payload: { nodeId: nodeEntry.node.id, pathKey: pathToKey(nodeEntry.path) },
+                      disabled: !isGroupedDraggableNode(nodeEntry)
+                    }, {
+                      default: vue.withCtx(() => [
+                        vue.createVNode(vue.unref(UiLogicTreeNode), {
+                          "path-key": pathToKey(nodeEntry.path),
+                          "node-view": resolveNodeView(nodeEntry),
+                          connectors: nodeEntry.connectors,
+                          conjunction: nodeEntry.conjunction,
+                          "conjunction-end-path-key": nodeEntry.conjunctionEndPathKey,
+                          "conjunction-label": resolveConjunctionLabel(nodeEntry.conjunction),
+                          "conjunction-offset": nodeEntry.conjunctionOffset,
+                          "conjunction-start-path-key": nodeEntry.conjunctionStartPathKey,
+                          "conjunction-tone": nodeEntry.conjunctionTone,
+                          grouped: Boolean(nodeEntry.sectionKey),
+                          "grouped-header": nodeEntry.node.childrenView === vue.unref(LogicTreeChildrenView).GROUPED,
+                          "grouped-position": nodeEntry.groupedPosition || void 0,
+                          editable: nodeEntry.node.data.editable,
+                          selected: isNodeSelected(nodeEntry),
+                          highlighted: Boolean(nodeEntry.node.data.highlighted),
+                          disabled: Boolean(nodeEntry.node.data.disabled),
+                          onNodeClick: ($event) => onNodeClick(nodeEntry),
+                          onNodeEdit: ($event) => setNodeEditable(nodeEntry, $event)
+                        }, {
+                          "conjunction-poppers": vue.withCtx(() => [
+                            vue.renderSlot(_ctx.$slots, "conjunction-poppers", vue.mergeProps({ ref_for: true }, resolveNodeSlotProps(nodeEntry)))
+                          ]),
+                          prefix: vue.withCtx(() => [
+                            vue.renderSlot(_ctx.$slots, "node-prefix", vue.mergeProps({ ref_for: true }, resolveNodeSlotProps(nodeEntry)))
+                          ]),
+                          content: vue.withCtx(() => [
+                            vue.createElementVNode("div", _hoisted_1$7, [
+                              vue.renderSlot(_ctx.$slots, "node", vue.mergeProps({ ref_for: true }, resolveNodeSlotProps(nodeEntry)), () => [
+                                _cache[0] || (_cache[0] = vue.createElementVNode("div", {
+                                  class: "ui-v1-logic-tree__slot-placeholder",
+                                  "data-ui-logic-tree-slot": "node"
+                                }, null, -1))
+                              ])
+                            ])
+                          ]),
+                          trailing: vue.withCtx(() => [
+                            vue.renderSlot(_ctx.$slots, "node-trailing", vue.mergeProps({ ref_for: true }, resolveNodeSlotProps(nodeEntry)))
+                          ]),
+                          _: 2
+                        }, 1032, ["path-key", "node-view", "connectors", "conjunction", "conjunction-end-path-key", "conjunction-label", "conjunction-offset", "conjunction-start-path-key", "conjunction-tone", "grouped", "grouped-header", "grouped-position", "editable", "selected", "highlighted", "disabled", "onNodeClick", "onNodeEdit"])
+                      ]),
+                      _: 2
+                    }, 1032, ["item-id", "container-id", "type", "index", "payload", "disabled"]);
+                  }), 128)),
+                  (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(entry.footerNodes, (nodeEntry) => {
+                    return vue.openBlock(), vue.createBlock(vue.unref(UiLogicTreeNode), {
+                      key: nodeEntry.node.id,
+                      "path-key": pathToKey(nodeEntry.path),
+                      "node-view": resolveNodeView(nodeEntry),
+                      connectors: nodeEntry.connectors,
+                      conjunction: nodeEntry.conjunction,
+                      "conjunction-end-path-key": nodeEntry.conjunctionEndPathKey,
+                      "conjunction-label": resolveConjunctionLabel(nodeEntry.conjunction),
+                      "conjunction-offset": nodeEntry.conjunctionOffset,
+                      "conjunction-start-path-key": nodeEntry.conjunctionStartPathKey,
+                      "conjunction-tone": nodeEntry.conjunctionTone,
+                      grouped: Boolean(nodeEntry.sectionKey),
+                      "grouped-header": nodeEntry.node.childrenView === vue.unref(LogicTreeChildrenView).GROUPED,
+                      "grouped-position": nodeEntry.groupedPosition || void 0,
+                      editable: nodeEntry.node.data.editable,
+                      selected: isNodeSelected(nodeEntry),
+                      highlighted: Boolean(nodeEntry.node.data.highlighted),
+                      disabled: Boolean(nodeEntry.node.data.disabled),
+                      onNodeClick: ($event) => onNodeClick(nodeEntry),
+                      onNodeEdit: ($event) => setNodeEditable(nodeEntry, $event)
+                    }, {
+                      "conjunction-poppers": vue.withCtx(() => [
+                        vue.renderSlot(_ctx.$slots, "conjunction-poppers", vue.mergeProps({ ref_for: true }, resolveNodeSlotProps(nodeEntry)))
+                      ]),
+                      prefix: vue.withCtx(() => [
+                        vue.renderSlot(_ctx.$slots, "node-prefix", vue.mergeProps({ ref_for: true }, resolveNodeSlotProps(nodeEntry)))
+                      ]),
+                      content: vue.withCtx(() => [
+                        vue.createElementVNode("div", _hoisted_2$3, [
+                          vue.renderSlot(_ctx.$slots, "node", vue.mergeProps({ ref_for: true }, resolveNodeSlotProps(nodeEntry)), () => [
+                            _cache[1] || (_cache[1] = vue.createElementVNode("div", {
+                              class: "ui-v1-logic-tree__slot-placeholder",
+                              "data-ui-logic-tree-slot": "node"
+                            }, null, -1))
+                          ])
+                        ])
+                      ]),
+                      trailing: vue.withCtx(() => [
+                        vue.renderSlot(_ctx.$slots, "node-trailing", vue.mergeProps({ ref_for: true }, resolveNodeSlotProps(nodeEntry)))
+                      ]),
+                      _: 2
+                    }, 1032, ["path-key", "node-view", "connectors", "conjunction", "conjunction-end-path-key", "conjunction-label", "conjunction-offset", "conjunction-start-path-key", "conjunction-tone", "grouped", "grouped-header", "grouped-position", "editable", "selected", "highlighted", "disabled", "onNodeClick", "onNodeEdit"]);
+                  }), 128))
+                ]),
+                _: 2
+              }, 1032, ["container-id", "accepts"])) : (vue.openBlock(), vue.createBlock(vue.unref(UiLogicTreeNode), {
+                key: 1,
+                "path-key": pathToKey(entry.item.path),
+                "node-view": resolveNodeView(entry.item),
+                connectors: entry.item.connectors,
+                conjunction: entry.item.conjunction,
+                "conjunction-end-path-key": entry.item.conjunctionEndPathKey,
+                "conjunction-label": resolveConjunctionLabel(entry.item.conjunction),
+                "conjunction-offset": entry.item.conjunctionOffset,
+                "conjunction-start-path-key": entry.item.conjunctionStartPathKey,
+                "conjunction-tone": entry.item.conjunctionTone,
+                grouped: Boolean(entry.item.sectionKey),
+                "grouped-header": entry.item.node.childrenView === vue.unref(LogicTreeChildrenView).GROUPED,
+                "grouped-position": entry.item.groupedPosition || void 0,
+                editable: entry.item.node.data.editable,
+                selected: isNodeSelected(entry.item),
+                highlighted: Boolean(entry.item.node.data.highlighted),
+                disabled: Boolean(entry.item.node.data.disabled),
+                onNodeClick: ($event) => onNodeClick(entry.item),
+                onNodeEdit: ($event) => setNodeEditable(entry.item, $event)
+              }, {
+                "conjunction-poppers": vue.withCtx(() => [
+                  vue.renderSlot(_ctx.$slots, "conjunction-poppers", vue.mergeProps({ ref_for: true }, resolveNodeSlotProps(entry.item)))
+                ]),
+                prefix: vue.withCtx(() => [
+                  vue.renderSlot(_ctx.$slots, "node-prefix", vue.mergeProps({ ref_for: true }, resolveNodeSlotProps(entry.item)))
+                ]),
+                content: vue.withCtx(() => [
+                  vue.createElementVNode("div", _hoisted_3$3, [
+                    vue.renderSlot(_ctx.$slots, "node", vue.mergeProps({ ref_for: true }, resolveNodeSlotProps(entry.item)), () => [
+                      _cache[2] || (_cache[2] = vue.createElementVNode("div", {
+                        class: "ui-v1-logic-tree__slot-placeholder",
+                        "data-ui-logic-tree-slot": "node"
+                      }, null, -1))
+                    ])
+                  ])
+                ]),
+                trailing: vue.withCtx(() => [
+                  vue.renderSlot(_ctx.$slots, "node-trailing", vue.mergeProps({ ref_for: true }, resolveNodeSlotProps(entry.item)))
+                ]),
+                _: 2
+              }, 1032, ["path-key", "node-view", "connectors", "conjunction", "conjunction-end-path-key", "conjunction-label", "conjunction-offset", "conjunction-start-path-key", "conjunction-tone", "grouped", "grouped-header", "grouped-position", "editable", "selected", "highlighted", "disabled", "onNodeClick", "onNodeEdit"]))
+            ], 64);
+          }), 128))
+        ]),
+        _: 3
+      });
+    };
+  }
+});
+const _hoisted_1$6 = {
+  xmlns: "http://www.w3.org/2000/svg",
+  viewBox: "0 0 20 20"
+};
+function render$2(_ctx, _cache) {
+  return vue.openBlock(), vue.createElementBlock("svg", _hoisted_1$6, [..._cache[0] || (_cache[0] = [
+    vue.createElementVNode("path", {
+      fill: "currentColor",
+      "fill-rule": "evenodd",
+      d: "M7.499 6.667a1.667 1.667 0 1 0 0-3.333 1.667 1.667 0 0 0 0 3.333M5.832 10a1.667 1.667 0 1 1 3.333 0 1.667 1.667 0 0 1-3.333 0m1.667 3.334a1.667 1.667 0 1 0 0 3.333 1.667 1.667 0 0 0 0-3.334M14.165 5a1.667 1.667 0 1 1-3.333 0 1.667 1.667 0 0 1 3.333 0M12.5 8.334a1.667 1.667 0 1 0 0 3.333 1.667 1.667 0 0 0 0-3.333M10.832 15a1.667 1.667 0 1 1 3.333 0 1.667 1.667 0 0 1-3.333 0",
+      "clip-rule": "evenodd"
+    }, null, -1)
+  ])]);
+}
+const IconDrag = { render: render$2 };
+const _sfc_main$c = /* @__PURE__ */ vue.defineComponent({
+  __name: "UiLogicTreeDragHandle",
+  props: {
+    disabled: { type: Boolean, default: false },
+    for: { default: void 0 }
+  },
+  setup(__props) {
+    const props = __props;
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createBlock(vue.unref(remote.RemoteDragHandle), {
+        for: props.for,
+        disabled: props.disabled,
+        class: vue.normalizeClass([{
+          "ui-v1-logic-tree-drag-handle_disabled": props.disabled
+        }, "ui-v1-logic-tree-drag-handle"]),
+        as: "span",
+        "data-skip-node-click": "true"
+      }, {
+        default: vue.withCtx(() => [
+          vue.renderSlot(_ctx.$slots, "default", {}, () => [
+            vue.createVNode(vue.unref(IconDrag), { "aria-hidden": "true" })
+          ])
+        ]),
+        _: 3
+      }, 8, ["for", "disabled", "class"]);
+    };
+  }
+});
 const UiModalSidebarType = "UiModalSidebar";
 const UiModalSidebar = remote.defineRemoteComponent(
   UiModalSidebarType,
@@ -414,7 +1372,7 @@ const _hoisted_4$1 = {
   key: 0,
   class: "ui-v1-page-header__addon"
 };
-const _sfc_main$a = /* @__PURE__ */ vue.defineComponent({
+const _sfc_main$b = /* @__PURE__ */ vue.defineComponent({
   ...{
     inheritAttrs: false
   },
@@ -558,6 +1516,225 @@ const _sfc_main$a = /* @__PURE__ */ vue.defineComponent({
     };
   }
 });
+var APPEARANCE$3 = /* @__PURE__ */ ((APPEARANCE2) => {
+  APPEARANCE2["OUTLINED"] = "outlined";
+  APPEARANCE2["PRIMARY"] = "primary";
+  APPEARANCE2["SECONDARY"] = "secondary";
+  APPEARANCE2["TERTIARY"] = "tertiary";
+  return APPEARANCE2;
+})(APPEARANCE$3 || {});
+var SIZE$5 = /* @__PURE__ */ ((SIZE2) => {
+  SIZE2["LG"] = "lg";
+  SIZE2["MD"] = "md";
+  SIZE2["SM"] = "sm";
+  SIZE2["XS"] = "xs";
+  return SIZE2;
+})(SIZE$5 || {});
+var VARIANT = /* @__PURE__ */ ((VARIANT2) => {
+  VARIANT2["DEFAULT"] = "default";
+  VARIANT2["SUCCESS"] = "success";
+  VARIANT2["DANGER"] = "danger";
+  return VARIANT2;
+})(VARIANT || {});
+const UiPopconfirmTriggerType = "UiPopconfirmTrigger";
+const UiPopconfirmTrigger = remote.defineRemoteComponent(UiPopconfirmTriggerType, {
+  emits: [
+    "click"
+  ]
+});
+const UiPopconfirmPopperType = "UiPopconfirmPopper";
+const UiPopconfirmPopper = remote.defineRemoteComponent(UiPopconfirmPopperType, {
+  emits: [
+    "update:visible",
+    "toggle",
+    "cancel",
+    "ok"
+  ],
+  methods: {
+    adjust: remote.defineRemoteMethod(),
+    close: remote.defineRemoteMethod(),
+    dispose: remote.defineRemoteMethod(),
+    open: remote.defineRemoteMethod()
+  },
+  slots: [
+    "title",
+    "cancel-text",
+    "ok-text"
+  ]
+});
+const _sfc_main$a = /* @__PURE__ */ vue.defineComponent({
+  __name: "UiPopconfirm",
+  props: {
+    id: {
+      type: String,
+      default: void 0
+    },
+    visible: {
+      type: Boolean,
+      default: false
+    },
+    title: {
+      type: String,
+      default: ""
+    },
+    okVariant: {
+      type: String,
+      default: VARIANT.DEFAULT
+    },
+    okTitle: {
+      type: null,
+      default: null
+    },
+    cancelTitle: {
+      type: null,
+      default: null
+    },
+    cancelAppearance: {
+      type: String,
+      default: APPEARANCE$3.SECONDARY
+    },
+    cancelVariant: {
+      type: String,
+      default: VARIANT.DEFAULT
+    },
+    buttonSize: {
+      type: String,
+      default: SIZE$5.XS
+    },
+    placement: {
+      type: [String, Object],
+      default: "bottom-start"
+    },
+    popperClass: {
+      type: null,
+      default: null
+    },
+    popperOptions: {
+      type: Object,
+      default: () => ({})
+    },
+    locale: {
+      type: String,
+      default: void 0
+    }
+  },
+  emits: ["update:visible", "toggle", "cancel", "ok"],
+  setup(__props, { expose: __expose, emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const popper = vue.useTemplateRef("popper");
+    const visibleState = vue.ref(props.visible);
+    const setVisible = (visible) => {
+      if (visibleState.value === visible) {
+        return;
+      }
+      visibleState.value = visible;
+      emit("update:visible", visible);
+      emit("toggle", visible);
+    };
+    const open = async () => {
+      setVisible(true);
+    };
+    const close = async () => {
+      setVisible(false);
+    };
+    const toggle = async () => {
+      if (visibleState.value) {
+        await close();
+      } else {
+        await open();
+      }
+    };
+    const onUpdateVisible = (visible) => {
+      setVisible(visible);
+    };
+    const onCancel = () => {
+      emit("cancel");
+      void close();
+    };
+    const onOk = () => {
+      emit("ok");
+      void close();
+    };
+    vue.watch(() => props.visible, (visible) => {
+      setVisible(visible);
+    });
+    __expose({
+      adjust: async () => {
+        await popper.value?.adjust();
+      },
+      close,
+      dispose: async () => {
+        await popper.value?.dispose();
+      },
+      open,
+      toggle
+    });
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createBlock(vue.unref(UiPopperConnector), null, {
+        default: vue.withCtx(() => [
+          vue.createVNode(vue.unref(UiPopconfirmTrigger), {
+            visible: visibleState.value,
+            onClick: toggle
+          }, {
+            default: vue.withCtx(() => [
+              vue.renderSlot(_ctx.$slots, "trigger", { open: visibleState.value }),
+              vue.createVNode(vue.unref(UiPopconfirmPopper), {
+                id: __props.id,
+                ref_key: "popper",
+                ref: popper,
+                visible: visibleState.value,
+                title: __props.title,
+                "ok-variant": __props.okVariant,
+                "ok-title": __props.okTitle,
+                "cancel-title": __props.cancelTitle,
+                "cancel-appearance": __props.cancelAppearance,
+                "cancel-variant": __props.cancelVariant,
+                "button-size": __props.buttonSize,
+                placement: __props.placement,
+                "popper-class": __props.popperClass,
+                "popper-options": __props.popperOptions,
+                locale: __props.locale,
+                onCancel,
+                onOk,
+                "onUpdate:visible": onUpdateVisible
+              }, vue.createSlots({
+                default: vue.withCtx(() => [
+                  vue.renderSlot(_ctx.$slots, "default")
+                ]),
+                _: 2
+              }, [
+                _ctx.$slots["title"] ? {
+                  name: "title",
+                  fn: vue.withCtx(() => [
+                    vue.renderSlot(_ctx.$slots, "title")
+                  ]),
+                  key: "0"
+                } : void 0,
+                _ctx.$slots["cancel-text"] ? {
+                  name: "cancel-text",
+                  fn: vue.withCtx(() => [
+                    vue.renderSlot(_ctx.$slots, "cancel-text")
+                  ]),
+                  key: "1"
+                } : void 0,
+                _ctx.$slots["ok-text"] ? {
+                  name: "ok-text",
+                  fn: vue.withCtx(() => [
+                    vue.renderSlot(_ctx.$slots, "ok-text")
+                  ]),
+                  key: "2"
+                } : void 0
+              ]), 1032, ["id", "visible", "title", "ok-variant", "ok-title", "cancel-title", "cancel-appearance", "cancel-variant", "button-size", "placement", "popper-class", "popper-options", "locale"])
+            ]),
+            _: 3
+          }, 8, ["visible"])
+        ]),
+        _: 3
+      });
+    };
+  }
+});
 const UiRadioType = "UiRadio";
 const UiRadio = remote.defineRemoteComponent(
   UiRadioType,
@@ -2048,143 +3225,6 @@ const UiMenuItemGroup = remote.defineRemoteComponent(
     "quantity"
   ]
 );
-const pluralization_en_GB = (choice) => choice === 1 ? 0 : 1;
-const pluralization_es_ES = (choice) => choice === 1 ? 0 : 1;
-const pluralization_ru_RU = (choice, choicesLength) => {
-  if (choicesLength === 2) {
-    return choice === 1 ? 0 : 1;
-  }
-  const mod100 = choice % 100;
-  return mod100 % 10 === 1 && mod100 !== 11 ? 0 : mod100 % 10 >= 2 && mod100 % 10 <= 4 && !(mod100 >= 10 && mod100 < 15) ? 1 : 2;
-};
-const get = (messages, path) => {
-  let i = 0;
-  let slice = messages[path[0]];
-  while (i < path.length) {
-    if (typeof slice === "string" && i + 1 === path.length) {
-      return slice;
-    }
-    if (typeof slice !== "object") {
-      return void 0;
-    }
-    slice = slice[path[++i]];
-  }
-  return slice;
-};
-const replace = (message, values) => {
-  return Object.keys(values).reduce((message2, key) => {
-    const pattern = new RegExp(`\\{${key}\\}`, "g");
-    const replacement = String(values[key]);
-    return message2.replace(pattern, replacement);
-  }, message);
-};
-const compile = (messages, path, values = void 0) => {
-  const message = get(messages, path);
-  if (typeof message === "string" && values) {
-    return replace(message, values);
-  }
-  return message;
-};
-const fail = (message) => {
-  throw new Error(message);
-};
-const t = (locale2, messages, path, values = void 0) => {
-  const keys = path.split(".");
-  if (locale2) {
-    const message = compile(messages[locale2] ?? {}, keys, values);
-    return typeof message !== "object" ? message : fail(`Translation for "${locale2}:${path}" is not translatable`);
-  }
-  return void 0;
-};
-const plural = (template, choice, rule) => {
-  const forms = template.split("|");
-  return forms[rule(choice, forms.length)];
-};
-class I18n {
-  parent;
-  messages;
-  computed;
-  pluralization;
-  fallback;
-  constructor(options = void 0, parent = void 0) {
-    this.parent = parent;
-    this.messages = options?.messages ?? {};
-    this.computed = options?.computed ?? {};
-    this.pluralization = {
-      "en-GB": pluralization_en_GB,
-      "es-ES": pluralization_es_ES,
-      "ru-RU": pluralization_ru_RU,
-      ...options?.pluralization ?? {}
-    };
-    this.fallback = options?.fallback;
-  }
-  t(locale2, path, values = void 0) {
-    try {
-      const _t = (locale22) => t(locale22, this.messages, path, values);
-      return _t(locale2) ?? _t(this.fallback) ?? fail(`Translation for "${path}" does not exists`);
-    } catch (e) {
-      if (this.parent) {
-        return this.parent.t(locale2, path, values);
-      }
-      throw e;
-    }
-  }
-  tc(locale2, path, choice, values = void 0) {
-    return plural(
-      this.t(
-        locale2,
-        path,
-        values
-      ),
-      choice,
-      this.pluralization[locale2]
-    );
-  }
-  compute(locale2, key, values) {
-    const computed = this.computed[key];
-    if (computed) {
-      return computed(localize(this, locale2), values);
-    }
-    if (this.parent) {
-      return this.parent.compute(locale2, key, values);
-    }
-    return fail("Key " + key + " is not registered");
-  }
-  extend(options) {
-    return new I18n({
-      pluralization: this.pluralization,
-      fallback: this.fallback,
-      ...options
-    }, this);
-  }
-}
-const localize = (i18n, locale2) => ({
-  t(path, values = void 0) {
-    return i18n.t(locale2, path, values);
-  },
-  tc(path, choice, values = void 0) {
-    return i18n.tc(locale2, path, choice, values);
-  },
-  compute(key, values) {
-    return i18n.compute(locale2, key, values);
-  }
-});
-const fallback = "en-GB";
-const define = (options = void 0, parent = void 0) => {
-  const i18n = new I18n({
-    ...options,
-    fallback
-  }, parent);
-  const extend = (i18n2, options2 = void 0) => options2 ? i18n2.extend(options2) : i18n2;
-  return {
-    i18n,
-    init: (locale2, options2 = void 0) => localize(
-      extend(i18n, options2),
-      locale2
-    ),
-    fallback
-  };
-};
 const selected$2 = "Selected";
 const search$2 = { "placeholder": "", "noResult": "Nothing found" };
 const messages_en_GB = {
@@ -2248,7 +3288,6 @@ const RegisterGroupKey = /* @__PURE__ */ Symbol("UiSelectOptionGroupRegister");
 const UnregisterGroupKey = /* @__PURE__ */ Symbol("UiSelectOptionGroupUnregister");
 const RegisterHeaderOptionKey = /* @__PURE__ */ Symbol("UiSelectOptionGroupRegisterHeaderOption");
 const UnregisterHeaderOptionKey = /* @__PURE__ */ Symbol("UiSelectOptionGroupUnregisterHeaderOption");
-const I18nInjectKey = /* @__PURE__ */ Symbol("$embedI18n");
 const UiSelectTriggerType = "UiSelectTrigger";
 const UiSelectTrigger = remote.defineRemoteComponent(UiSelectTriggerType, {
   emits: [
@@ -3061,6 +4100,11 @@ const createEndpointRoot = async (channel) => {
     "UiInfobox",
     "UiLink",
     "UiLoader",
+    "UiLogicTreeCaret",
+    "UiLogicTreeNode",
+    "UiLogicTreeNodeIcon",
+    "UiLogicTreeNodeItem",
+    "UiLogicTreeRoot",
     "UiMenuItem",
     "UiMenuItemGroup",
     "UiModalSidebar",
@@ -3070,6 +4114,8 @@ const createEndpointRoot = async (channel) => {
     "UiPageHeader",
     "UiPageHeaderLayout",
     "UiPageHeaderTitle",
+    "UiPopconfirmPopper",
+    "UiPopconfirmTrigger",
     "UiPopper",
     "UiPopperConnector",
     "UiPopperTarget",
@@ -3192,6 +4238,11 @@ function detectLocale() {
 exports.ALIGN = ALIGN;
 exports.DIRECTION = DIRECTION;
 exports.ImageWorkersKey = ImageWorkersKey;
+exports.LogicTreeChildrenView = LogicTreeChildrenView;
+exports.LogicTreeConjunction = LogicTreeConjunction;
+exports.LogicTreeNodeKind = LogicTreeNodeKind;
+exports.LogicTreeNodeView = LogicTreeNodeView;
+exports.LogicTreeTone = LogicTreeTone;
 exports.RADIO_SWITCH_APPEARANCE = APPEARANCE$2;
 exports.RADIO_SWITCH_SIZE = SIZE$4;
 exports.SKELETON_ANIMATION = ANIMATION;
@@ -3227,13 +4278,18 @@ exports.UiDatePickerType = UiDatePickerType;
 exports.UiDateType = UiDateType;
 exports.UiError = UiError;
 exports.UiErrorType = UiErrorType;
-exports.UiField = _sfc_main$b;
+exports.UiField = _sfc_main$e;
 exports.UiInfobox = UiInfobox;
 exports.UiInfoboxType = UiInfoboxType;
 exports.UiLink = UiLink;
 exports.UiLinkType = UiLinkType;
 exports.UiLoader = UiLoader;
 exports.UiLoaderType = UiLoaderType;
+exports.UiLogicTree = _sfc_main$d;
+exports.UiLogicTreeCaret = UiLogicTreeCaret;
+exports.UiLogicTreeDragHandle = _sfc_main$c;
+exports.UiLogicTreeNodeIcon = UiLogicTreeNodeIcon;
+exports.UiLogicTreeNodeItem = UiLogicTreeNodeItem;
 exports.UiMenuItem = UiMenuItem;
 exports.UiMenuItemGroup = UiMenuItemGroup;
 exports.UiMenuItemGroupType = UiMenuItemGroupType;
@@ -3246,7 +4302,8 @@ exports.UiModalWindowSurfaceType = UiModalWindowSurfaceType;
 exports.UiModalWindowType = UiModalWindowType;
 exports.UiNumberStepper = UiNumberStepper;
 exports.UiNumberStepperType = UiNumberStepperType;
-exports.UiPageHeader = _sfc_main$a;
+exports.UiPageHeader = _sfc_main$b;
+exports.UiPopconfirm = _sfc_main$a;
 exports.UiPopper = UiPopper;
 exports.UiPopperConnector = UiPopperConnector;
 exports.UiPopperConnectorType = UiPopperConnectorType;