@godxjp/chat 32.0.0 → 32.0.1

package/dist/chunk-DEYHFJBA.js

@@ -0,0 +1,312 @@
+"use client";
+
+// src/chat-suggestion.tsx
+import * as React from "react";
+import { useTranslation } from "@godxjp/ui/i18n";
+import { cn } from "@godxjp/ui/lib/utils";
+import { VisuallyHidden } from "@godxjp/ui/general";
+import { Popover, PopoverAnchor, PopoverContent } from "@godxjp/ui/data-display";
+import { Command, CommandEmpty, CommandItem, CommandList } from "@godxjp/ui/data-entry";
+import { isImeComposing } from "@godxjp/ui/data-entry";
+import { jsx, jsxs } from "react/jsx-runtime";
+function matchTrigger(text, caret, trigger, { allowSpaces = false, terminator } = {}) {
+  if (!trigger) return null;
+  const before = text.slice(0, caret);
+  const start = before.lastIndexOf(trigger);
+  if (start === -1) return null;
+  const query = before.slice(start + trigger.length);
+  if (allowSpaces ? /\n/.test(query) : /\s/.test(query)) return null;
+  if (terminator && query.includes(terminator)) return null;
+  const preceding = start === 0 ? "" : before[start - 1];
+  if (trigger.length === 1 && preceding !== "" && !/\s/.test(preceding) && preceding.charCodeAt(0) < 128) {
+    return null;
+  }
+  return { query, start };
+}
+function levelItems(items, path) {
+  let current = items;
+  for (const step of path) {
+    const next = current.find((item) => item.value === step)?.children;
+    if (!next) return current;
+    current = next;
+  }
+  return current;
+}
+function labelOf(item) {
+  return item.label ?? item.value;
+}
+function matches(item, query) {
+  if (!query) return true;
+  const needle = query.toLocaleLowerCase();
+  return labelOf(item).toLocaleLowerCase().includes(needle) || item.value.toLocaleLowerCase().includes(needle) || (item.description?.toLocaleLowerCase().includes(needle) ?? false);
+}
+function ChatSuggestion({
+  items,
+  onValueChange,
+  triggerCharacter = "/",
+  open,
+  defaultOpen,
+  onOpenChange,
+  children,
+  emptyMessage,
+  listLabel: listLabelProp,
+  id,
+  className,
+  allowSpaces = false,
+  terminator,
+  shouldFilter = true,
+  onQueryChange
+}) {
+  const { t } = useTranslation();
+  const [uncontrolledOpen, setUncontrolledOpen] = React.useState(defaultOpen ?? false);
+  const isOpen = open ?? uncontrolledOpen;
+  const [query, setQuery] = React.useState("");
+  const [path, setPath] = React.useState([]);
+  const [activeValue, setActiveValue] = React.useState("");
+  const [activeId, setActiveId] = React.useState(void 0);
+  const anchorRef = React.useRef(null);
+  const contentRef = React.useRef(null);
+  const [listId, setListId] = React.useState(void 0);
+  const field = React.useCallback(() => anchorRef.current?.querySelector("textarea") ?? null, []);
+  const openRef = React.useRef(isOpen);
+  openRef.current = isOpen;
+  const setOpen = React.useCallback(
+    (next) => {
+      if (openRef.current === next) return;
+      openRef.current = next;
+      if (open === void 0) setUncontrolledOpen(next);
+      onOpenChange?.(next);
+      if (!next) {
+        setQuery("");
+        setPath([]);
+      }
+    },
+    [open, onOpenChange]
+  );
+  const visible = React.useMemo(() => {
+    const level = levelItems(items, path);
+    return shouldFilter ? level.filter((item) => matches(item, query)) : level;
+  }, [items, path, query, shouldFilter]);
+  React.useEffect(() => {
+    if (isOpen) onQueryChange?.(query);
+  }, [isOpen, query, onQueryChange]);
+  const enabled = React.useMemo(() => visible.filter((item) => !item.disabled), [visible]);
+  React.useEffect(() => {
+    if (enabled.length === 0) {
+      setActiveValue("");
+      return;
+    }
+    setActiveValue(
+      (current) => enabled.some((item) => item.value === current) ? current : enabled[0].value
+    );
+  }, [enabled]);
+  React.useEffect(() => {
+    if (!isOpen) {
+      setListId(void 0);
+      setActiveId(void 0);
+      return;
+    }
+    const content = contentRef.current;
+    setListId(content?.querySelector("[cmdk-list]")?.id || void 0);
+    setActiveId(content?.querySelector('[cmdk-item][aria-selected="true"]')?.id || void 0);
+  });
+  const dismissedStartRef = React.useRef(null);
+  const close = React.useCallback(() => {
+    const node = field();
+    const caret = node ? node.selectionStart ?? node.value.length : 0;
+    const hit = node ? matchTrigger(node.value, caret, triggerCharacter, { allowSpaces, terminator }) : null;
+    dismissedStartRef.current = hit ? hit.start : null;
+    setOpen(false);
+    field()?.focus();
+  }, [field, setOpen, triggerCharacter, allowSpaces, terminator]);
+  const evaluate = React.useCallback(() => {
+    const node = field();
+    if (!node) return;
+    const caret = node.selectionStart ?? node.value.length;
+    const hit = matchTrigger(node.value, caret, triggerCharacter, { allowSpaces, terminator });
+    if (!hit) {
+      dismissedStartRef.current = null;
+      setOpen(false);
+      return;
+    }
+    if (hit.start === dismissedStartRef.current) {
+      setOpen(false);
+      return;
+    }
+    dismissedStartRef.current = null;
+    setQuery(hit.query);
+    setOpen(true);
+  }, [field, setOpen, triggerCharacter, allowSpaces, terminator]);
+  const onTrigger = React.useCallback(
+    (next) => {
+      if (next === false) {
+        setOpen(false);
+        return;
+      }
+      if (next === void 0) {
+        setQuery("");
+        setOpen(true);
+        return;
+      }
+      window.setTimeout(evaluate, 0);
+    },
+    [evaluate, setOpen]
+  );
+  const pick = React.useCallback(
+    (item) => {
+      if (item.disabled) return;
+      if (item.children && item.children.length > 0) {
+        setPath((current) => [...current, item.value]);
+        setQuery("");
+        field()?.focus();
+        return;
+      }
+      onValueChange?.(item.value);
+      setOpen(false);
+      field()?.focus();
+    },
+    [field, onValueChange, setOpen]
+  );
+  const move = React.useCallback(
+    (direction) => {
+      if (enabled.length === 0) return;
+      const index = enabled.findIndex((item) => item.value === activeValue);
+      const from = index === -1 ? direction === 1 ? -1 : 0 : index;
+      const next = (from + direction + enabled.length) % enabled.length;
+      setActiveValue(enabled[next].value);
+    },
+    [activeValue, enabled]
+  );
+  const onKeyDown = React.useCallback(
+    (event) => {
+      if (isImeComposing(event)) return;
+      if (!openRef.current) {
+        if (event.key.startsWith("Arrow") || event.key === "Home" || event.key === "End") {
+          window.setTimeout(evaluate, 0);
+        }
+        return;
+      }
+      switch (event.key) {
+        case "ArrowDown":
+          event.preventDefault();
+          move(1);
+          return;
+        case "ArrowUp":
+          event.preventDefault();
+          move(-1);
+          return;
+        case "Enter":
+        case "Tab": {
+          const item = enabled.find((candidate) => candidate.value === activeValue);
+          if (!item) return;
+          event.preventDefault();
+          pick(item);
+          return;
+        }
+        case "Escape":
+          event.preventDefault();
+          event.stopPropagation();
+          close();
+          return;
+        default:
+          if (event.key.startsWith("Arrow") || event.key === "Home" || event.key === "End") {
+            window.setTimeout(evaluate, 0);
+          }
+      }
+    },
+    [activeValue, close, enabled, evaluate, move, pick]
+  );
+  const listLabel = listLabelProp ?? t("dataEntry.chatSuggestion.label");
+  return /* @__PURE__ */ jsxs(Popover, { open: isOpen, onOpenChange: setOpen, children: [
+    /* @__PURE__ */ jsxs(
+      PopoverAnchor,
+      {
+        ref: anchorRef,
+        id,
+        "data-slot": "chat-suggestion",
+        className: cn("block w-full", className),
+        onPointerUp: () => window.setTimeout(evaluate, 0),
+        onBlurCapture: (event) => {
+          const next = event.relatedTarget;
+          if (next && anchorRef.current?.contains(next)) return;
+          if (openRef.current) setOpen(false);
+        },
+        children: [
+          children({
+            onTrigger,
+            onKeyDown
+          }),
+          /* @__PURE__ */ jsx(FieldPopupWiring, { field, open: isOpen, listId, activeId }),
+          /* @__PURE__ */ jsx(VisuallyHidden, { role: "status", "aria-live": "polite", children: isOpen ? t("dataEntry.chatSuggestion.count", { count: visible.length }) : "" })
+        ]
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      PopoverContent,
+      {
+        ref: contentRef,
+        flush: true,
+        align: "start",
+        "aria-label": listLabel,
+        className: "ui-chat-suggestion-panel",
+        onOpenAutoFocus: (event) => event.preventDefault(),
+        onCloseAutoFocus: (event) => event.preventDefault(),
+        children: /* @__PURE__ */ jsx(
+          Command,
+          {
+            value: activeValue,
+            onValueChange: setActiveValue,
+            shouldFilter: false,
+            label: listLabel,
+            children: /* @__PURE__ */ jsxs(CommandList, { label: listLabel, children: [
+              /* @__PURE__ */ jsx(CommandEmpty, { children: emptyMessage ?? t("dataEntry.chatSuggestion.empty") }),
+              visible.map((item) => /* @__PURE__ */ jsxs(
+                CommandItem,
+                {
+                  value: item.value,
+                  disabled: item.disabled,
+                  onSelect: () => pick(item),
+                  children: [
+                    item.icon ? /* @__PURE__ */ jsx("span", { className: "flex shrink-0 items-center", "aria-hidden": "true", children: item.icon }) : null,
+                    /* @__PURE__ */ jsxs("span", { className: "ui-chat-suggestion-item-text", children: [
+                      /* @__PURE__ */ jsx("span", { className: "truncate", children: labelOf(item) }),
+                      item.description ? /* @__PURE__ */ jsx("span", { className: "text-muted-foreground truncate text-xs", children: item.description }) : null
+                    ] })
+                  ]
+                },
+                item.value
+              ))
+            ] })
+          }
+        )
+      }
+    )
+  ] });
+}
+ChatSuggestion.displayName = "ChatSuggestion";
+function FieldPopupWiring({
+  field,
+  open,
+  listId,
+  activeId
+}) {
+  React.useEffect(() => {
+    const node = field();
+    if (!node) return;
+    node.setAttribute("aria-haspopup", "listbox");
+    node.setAttribute("aria-autocomplete", "list");
+    if (open && listId) {
+      node.setAttribute("aria-controls", listId);
+      if (activeId) node.setAttribute("aria-activedescendant", activeId);
+      else node.removeAttribute("aria-activedescendant");
+    } else {
+      node.removeAttribute("aria-controls");
+      node.removeAttribute("aria-activedescendant");
+    }
+  }, [activeId, field, listId, open]);
+  return null;
+}
+
+export {
+  ChatSuggestion
+};

package/dist/chunk-IWWOS4BL.js

@@ -0,0 +1,374 @@
+"use client";
+
+// src/conversations.tsx
+import * as React from "react";
+import { ChevronDown, MoreHorizontal, Plus } from "lucide-react";
+import { useTranslation } from "@godxjp/ui/i18n";
+import { formatDate } from "@godxjp/ui/datetime";
+import { cn } from "@godxjp/ui/lib/utils";
+import { Button } from "@godxjp/ui/general";
+import { Text } from "@godxjp/ui/general";
+import { Separator } from "@godxjp/ui/layout";
+import {
+  DropdownMenu,
+  DropdownMenuContent,
+  DropdownMenuItem,
+  DropdownMenuTrigger
+} from "@godxjp/ui/navigation";
+import { jsx, jsxs } from "react/jsx-runtime";
+function isDivider(entry) {
+  return "type" in entry && entry.type === "divider";
+}
+function isRtl(element) {
+  return element?.closest("[dir]")?.getAttribute("dir")?.toLowerCase() === "rtl";
+}
+function toSections(items, groupable) {
+  const collapsibleOption = typeof groupable === "object" ? groupable.collapsible : void 0;
+  const sections = [];
+  for (const entry of items) {
+    const group = !groupable || isDivider(entry) ? void 0 : entry.group;
+    if (group === void 0) {
+      const tail = sections[sections.length - 1];
+      if (tail && tail.group === void 0) {
+        tail.entries.push(entry);
+        continue;
+      }
+      sections.push({ entries: [entry], collapsible: false });
+      continue;
+    }
+    const existing = sections.find((section) => section.group === group);
+    if (existing) {
+      existing.entries.push(entry);
+      continue;
+    }
+    sections.push({
+      group,
+      entries: [entry],
+      collapsible: typeof collapsibleOption === "function" ? collapsibleOption(group) : collapsibleOption ?? false
+    });
+  }
+  return sections;
+}
+var groupNavKey = (group) => `group:${group}`;
+var rowNavKey = (key) => `row:${key}`;
+var Conversations = React.forwardRef(
+  ({
+    items = [],
+    activeKey,
+    defaultActiveKey,
+    onActiveChange,
+    menu,
+    groupable,
+    creation,
+    label,
+    id,
+    className,
+    ...rest
+  }, ref) => {
+    const { t } = useTranslation();
+    const rootRef = React.useRef(null);
+    const setRootRef = React.useCallback(
+      (node) => {
+        rootRef.current = node;
+        if (typeof ref === "function") ref(node);
+        else if (ref) ref.current = node;
+      },
+      [ref]
+    );
+    const [uncontrolledActive, setUncontrolledActive] = React.useState(defaultActiveKey);
+    const mergedActiveKey = activeKey ?? uncontrolledActive;
+    const sections = React.useMemo(() => toSections(items, groupable), [items, groupable]);
+    const groupOptions = typeof groupable === "object" ? groupable : {};
+    const collapsibleGroups = React.useMemo(
+      () => sections.filter((section) => section.collapsible && section.group).map((s) => s.group),
+      [sections]
+    );
+    const [uncontrolledExpanded, setUncontrolledExpanded] = React.useState(() => [
+      ...groupOptions.defaultExpandedKeys ?? collapsibleGroups
+    ]);
+    const expandedKeys = groupOptions.expandedKeys ? [...groupOptions.expandedKeys] : uncontrolledExpanded;
+    const toggleGroup = (group) => {
+      const next = expandedKeys.includes(group) ? expandedKeys.filter((key) => key !== group) : [...expandedKeys, group];
+      if (!groupOptions.expandedKeys) setUncontrolledExpanded(next);
+      groupOptions.onExpand?.(next);
+    };
+    const navKeys = [];
+    for (const section of sections) {
+      if (section.group && section.collapsible) {
+        navKeys.push(groupNavKey(section.group));
+        if (!expandedKeys.includes(section.group)) continue;
+      }
+      for (const entry of section.entries) {
+        if (!isDivider(entry) && !entry.disabled) navKeys.push(rowNavKey(entry.key));
+      }
+    }
+    const [focusKey, setFocusKey] = React.useState(null);
+    const activeNavKey = mergedActiveKey ? rowNavKey(mergedActiveKey) : void 0;
+    const tabStop = focusKey && navKeys.includes(focusKey) ? focusKey : activeNavKey && navKeys.includes(activeNavKey) ? activeNavKey : navKeys[0];
+    const nodes = React.useRef(/* @__PURE__ */ new Map());
+    const registerNode = (key) => (node) => {
+      if (node) nodes.current.set(key, node);
+      else nodes.current.delete(key);
+    };
+    const moveTo = (key) => {
+      if (!key) return;
+      setFocusKey(key);
+      nodes.current.get(key)?.focus();
+    };
+    const step = (from, delta) => {
+      if (navKeys.length === 0) return;
+      const index = navKeys.indexOf(from);
+      const next = index === -1 ? 0 : (index + delta + navKeys.length) % navKeys.length;
+      moveTo(navKeys[next]);
+    };
+    const handleNavKeyDown = (navKey) => (event) => {
+      const rtl = isRtl(event.currentTarget);
+      const forward = rtl ? "ArrowLeft" : "ArrowRight";
+      const backward = rtl ? "ArrowRight" : "ArrowLeft";
+      switch (event.key) {
+        case "ArrowDown":
+          event.preventDefault();
+          step(navKey, 1);
+          return;
+        case "ArrowUp":
+          event.preventDefault();
+          step(navKey, -1);
+          return;
+        case "Home":
+          event.preventDefault();
+          moveTo(navKeys[0]);
+          return;
+        case "End":
+          event.preventDefault();
+          moveTo(navKeys[navKeys.length - 1]);
+          return;
+        case forward: {
+          const trigger = nodes.current.get(`menu:${navKey}`);
+          if (!trigger) return;
+          event.preventDefault();
+          trigger.focus();
+          return;
+        }
+        case backward: {
+          if (!navKey.startsWith("menu:")) return;
+          event.preventDefault();
+          moveTo(navKey.slice("menu:".length));
+          return;
+        }
+        default:
+      }
+    };
+    const selectConversation = (item) => {
+      if (item.disabled) return;
+      if (activeKey === void 0) setUncontrolledActive(item.key);
+      onActiveChange?.(
+        item.key,
+        items.find((entry) => !isDivider(entry) && entry.key === item.key)
+      );
+    };
+    const menuFor = (item) => {
+      const resolved = typeof menu === "function" ? menu(item) : menu;
+      return resolved && resolved.items.length > 0 ? resolved : void 0;
+    };
+    const renderEntry = (entry, index) => {
+      if (isDivider(entry)) {
+        return /* @__PURE__ */ jsx("li", { className: "ui-conversations-rule", children: /* @__PURE__ */ jsx(
+          Separator,
+          {
+            "data-dashed": entry.dashed ? "true" : void 0,
+            className: "ui-conversations-separator"
+          }
+        ) }, entry.key ?? `divider-${index}`);
+      }
+      const navKey = rowNavKey(entry.key);
+      const active = mergedActiveKey === entry.key;
+      const rowMenu = entry.disabled ? void 0 : menuFor(entry);
+      const labelText = typeof entry.label === "string" ? entry.label : entry.key;
+      return /* @__PURE__ */ jsxs(
+        "li",
+        {
+          "data-slot": "conversations-item",
+          "data-active": active ? "true" : void 0,
+          className: "ui-conversations-item",
+          children: [
+            /* @__PURE__ */ jsxs(
+              Button,
+              {
+                ref: registerNode(navKey),
+                type: "button",
+                variant: "ghost",
+                fullWidth: true,
+                align: "start",
+                disabled: entry.disabled,
+                "aria-current": active ? "true" : void 0,
+                tabIndex: tabStop === navKey ? 0 : -1,
+                className: "ui-conversations-row",
+                onFocus: () => setFocusKey(navKey),
+                onClick: () => selectConversation(entry),
+                onKeyDown: handleNavKeyDown(navKey),
+                children: [
+                  entry.icon ? /* @__PURE__ */ jsx("span", { className: "ui-conversations-icon", "aria-hidden": "true", children: entry.icon }) : null,
+                  /* @__PURE__ */ jsxs("span", { className: "ui-conversations-line", children: [
+                    /* @__PURE__ */ jsx(Text, { truncate: true, children: entry.label }),
+                    entry.timestamp === void 0 ? null : (
+                      /*
+                       * Through `formatDate`, never through `toLocaleString` or a sliced ISO string.
+                       * `docs/DATETIME.md` rule 1 forbids the alternatives for a measured reason: the
+                       * tenant's locale, timezone and 12/24h choice live in AppProvider, so the same
+                       * epoch has to read 2026/03/15 in a Japanese tenant and 15/03/2026 in a
+                       * Vietnamese one. A component that formats its own dates cannot do that.
+                       */
+                      /* @__PURE__ */ jsx(Text, { size: "xs", tone: "muted", tabular: true, className: "ui-conversations-timestamp", children: formatDate(new Date(entry.timestamp)) })
+                    )
+                  ] })
+                ]
+              }
+            ),
+            rowMenu ? /* @__PURE__ */ jsxs(DropdownMenu, { children: [
+              /* @__PURE__ */ jsx(DropdownMenuTrigger, { asChild: true, children: /* @__PURE__ */ jsx(
+                Button,
+                {
+                  ref: registerNode(`menu:${navKey}`),
+                  type: "button",
+                  variant: "ghost",
+                  size: "icon-sm",
+                  tabIndex: -1,
+                  className: "ui-conversations-menu-trigger",
+                  "aria-label": rowMenu.triggerLabel?.(entry) ?? t("navigation.conversations.rowActions", { label: labelText }),
+                  onKeyDown: handleNavKeyDown(`menu:${navKey}`),
+                  children: /* @__PURE__ */ jsx(MoreHorizontal, { "aria-hidden": "true" })
+                }
+              ) }),
+              /* @__PURE__ */ jsx(DropdownMenuContent, { align: "end", children: rowMenu.items.map((command) => /* @__PURE__ */ jsxs(
+                DropdownMenuItem,
+                {
+                  disabled: command.disabled,
+                  variant: command.danger ? "destructive" : void 0,
+                  onSelect: () => rowMenu.onClick?.({ key: command.key, conversation: entry }),
+                  children: [
+                    command.icon,
+                    command.label
+                  ]
+                },
+                command.key
+              )) })
+            ] }) : null
+          ]
+        },
+        entry.key
+      );
+    };
+    const railLabel = label ?? t("navigation.conversations.label");
+    return /* @__PURE__ */ jsxs(
+      "div",
+      {
+        ref: setRootRef,
+        id,
+        "data-slot": "conversations",
+        className: cn("ui-conversations", className),
+        ...rest,
+        children: [
+          creation ? /* @__PURE__ */ jsx(CreationButton, { creation }) : null,
+          sections.map((section, sectionIndex) => {
+            if (!section.group) {
+              return /* @__PURE__ */ jsx(
+                "ul",
+                {
+                  "aria-label": railLabel,
+                  className: "ui-conversations-list",
+                  children: section.entries.map(renderEntry)
+                },
+                `run-${sectionIndex}`
+              );
+            }
+            const heading = typeof groupOptions.label === "function" ? groupOptions.label(section.group) : groupOptions.label ?? section.group;
+            const navKey = groupNavKey(section.group);
+            const expanded = expandedKeys.includes(section.group);
+            const listId = `${id ?? "ui-conversations"}-${section.group}`;
+            return /* @__PURE__ */ jsxs(
+              "div",
+              {
+                "data-slot": "conversations-group",
+                className: "ui-conversations-group",
+                children: [
+                  section.collapsible ? /* @__PURE__ */ jsxs(
+                    Button,
+                    {
+                      ref: registerNode(navKey),
+                      type: "button",
+                      variant: "ghost",
+                      size: "sm",
+                      fullWidth: true,
+                      align: "start",
+                      "aria-expanded": expanded,
+                      "aria-controls": listId,
+                      tabIndex: tabStop === navKey ? 0 : -1,
+                      className: "ui-conversations-group-trigger",
+                      onFocus: () => setFocusKey(navKey),
+                      onClick: () => toggleGroup(section.group),
+                      onKeyDown: handleNavKeyDown(navKey),
+                      children: [
+                        /* @__PURE__ */ jsx(
+                          ChevronDown,
+                          {
+                            "aria-hidden": "true",
+                            className: "ui-conversations-group-chevron",
+                            "data-expanded": expanded ? "true" : void 0
+                          }
+                        ),
+                        /* @__PURE__ */ jsx(Text, { size: "xs", tone: "muted", weight: "medium", truncate: true, children: heading })
+                      ]
+                    }
+                  ) : /* @__PURE__ */ jsx(
+                    Text,
+                    {
+                      size: "xs",
+                      tone: "muted",
+                      weight: "medium",
+                      className: "ui-conversations-group-label",
+                      children: heading
+                    }
+                  ),
+                  section.collapsible && !expanded ? null : /* @__PURE__ */ jsx(
+                    "ul",
+                    {
+                      id: listId,
+                      "aria-label": typeof heading === "string" ? heading : section.group,
+                      className: "ui-conversations-list",
+                      children: section.entries.map(renderEntry)
+                    }
+                  )
+                ]
+              },
+              section.group
+            );
+          })
+        ]
+      }
+    );
+  }
+);
+Conversations.displayName = "Conversations";
+function CreationButton({ creation }) {
+  const { t } = useTranslation();
+  return /* @__PURE__ */ jsxs(
+    Button,
+    {
+      type: "button",
+      variant: "outline",
+      fullWidth: true,
+      align: "start",
+      disabled: creation.disabled,
+      className: "ui-conversations-creation",
+      onClick: () => creation.onClick?.(),
+      children: [
+        creation.icon ?? /* @__PURE__ */ jsx(Plus, { "aria-hidden": "true" }),
+        creation.label ?? t("navigation.conversations.creation")
+      ]
+    }
+  );
+}
+
+export {
+  Conversations
+};