@bitrix24/b24ui-nuxt 2.1.10 → 2.1.12

package/dist/runtime/utils/editor.js

@@ -0,0 +1,364 @@
+import { flip, shift, offset, size, autoPlacement, hide, inline } from "@floating-ui/dom";
+import { isArrayOfArray } from "./index.js";
+export function isMarkInSchema(mark, editor) {
+  if (!editor?.schema) {
+    return false;
+  }
+  const markName = typeof mark === "string" ? mark : mark.name;
+  return editor.schema.spec.marks.get(markName) !== void 0;
+}
+export function isNodeTypeSelected(editor, nodeTypes) {
+  if (!editor) {
+    return false;
+  }
+  const { selection } = editor.state;
+  const { $from, to } = selection;
+  return nodeTypes.some((nodeType) => {
+    return editor.state.doc.nodesBetween($from.pos, to, (node) => {
+      return node.type.name === nodeType;
+    });
+  });
+}
+export function isExtensionAvailable(editor, extensionName) {
+  if (!editor) {
+    return false;
+  }
+  return editor.extensionManager.extensions.some((ext) => ext.name === extensionName);
+}
+export function createToggleHandler(name) {
+  const fnName = `toggle${name.charAt(0).toUpperCase()}${name.slice(1)}`;
+  return {
+    canExecute: (editor) => editor.can()[fnName](),
+    execute: (editor) => editor.chain().focus()[fnName](),
+    isActive: (editor) => editor.isActive(name),
+    isDisabled: (editor) => isNodeTypeSelected(editor, ["image"]) || editor.isActive("code")
+  };
+}
+export function createSetHandler(name) {
+  const fnName = `set${name.charAt(0).toUpperCase()}${name.slice(1)}`;
+  return {
+    canExecute: (editor) => editor.can()[fnName](),
+    execute: (editor) => editor.chain().focus()[fnName](),
+    isActive: (editor) => editor.isActive(name),
+    isDisabled: (editor) => isNodeTypeSelected(editor, ["image"]) || editor.isActive("code")
+  };
+}
+export function createSimpleHandler(name) {
+  return {
+    canExecute: (editor) => editor.can()[name](),
+    execute: (editor) => editor.chain()[name](),
+    isActive: () => false,
+    isDisabled: void 0
+  };
+}
+export function createMarkHandler() {
+  return {
+    canExecute: (editor, cmd) => editor.can().toggleMark(cmd.mark),
+    execute: (editor, cmd) => editor.chain().focus().toggleMark(cmd.mark),
+    isActive: (editor, cmd) => editor.isActive(cmd.mark),
+    isDisabled: (editor, cmd) => !isMarkInSchema(cmd.mark, editor) || isNodeTypeSelected(editor, ["image"])
+  };
+}
+export function createTextAlignHandler() {
+  return {
+    canExecute: (editor, cmd) => editor.can().setTextAlign(cmd.align),
+    execute: (editor, cmd) => editor.chain().focus().setTextAlign(cmd.align),
+    isActive: (editor, cmd) => editor.isActive({ textAlign: cmd.align }),
+    isDisabled: (editor) => !isExtensionAvailable(editor, "textAlign") || isNodeTypeSelected(editor, ["image", "horizontalRule"])
+  };
+}
+export function createHeadingHandler() {
+  return {
+    canExecute: (editor, cmd) => editor.can().toggleHeading({ level: cmd.level }),
+    execute: (editor, cmd) => editor.chain().focus().toggleHeading({ level: cmd.level }),
+    isActive: (editor, cmd) => editor.isActive("heading", { level: cmd.level }),
+    isDisabled: (editor) => isNodeTypeSelected(editor, ["image"]) || editor.isActive("code")
+  };
+}
+export function createLinkHandler() {
+  return {
+    canExecute: (editor) => {
+      return editor.can().setLink({ href: "" }) || editor.can().unsetLink();
+    },
+    execute: (editor, cmd) => {
+      const chain = editor.chain();
+      const previousUrl = editor.getAttributes("link").href;
+      if (previousUrl) {
+        return chain.focus().unsetLink();
+      }
+      if (cmd?.href) {
+        return chain.focus().setLink({ href: cmd.href });
+      }
+      const href = prompt("Enter the URL:");
+      if (href) {
+        return chain.focus().setLink({ href });
+      }
+      return chain;
+    },
+    isActive: (editor) => editor.isActive("link"),
+    isDisabled: (editor) => {
+      if (!isExtensionAvailable(editor, "link") || isNodeTypeSelected(editor, ["image"])) {
+        return true;
+      }
+      const { selection } = editor.state;
+      return selection.empty && !editor.isActive("link");
+    }
+  };
+}
+export function createImageHandler() {
+  return {
+    canExecute: (editor) => {
+      return editor.can().setImage({ src: "" });
+    },
+    execute: (editor, cmd) => {
+      const chain = editor.chain().focus();
+      if (cmd?.src) {
+        return chain.setImage({ src: cmd.src });
+      }
+      const src = prompt("Enter the image URL:");
+      if (src) {
+        return chain.setImage({ src });
+      }
+      return chain;
+    },
+    isActive: (editor) => editor.isActive("image"),
+    isDisabled: (editor) => {
+      return !isExtensionAvailable(editor, "image");
+    }
+  };
+}
+export function createListHandler(listType) {
+  const fnName = listType === "bulletList" ? "toggleBulletList" : "toggleOrderedList";
+  return {
+    canExecute: (editor) => {
+      return editor.can()[fnName]() || editor.isActive("bulletList") || editor.isActive("orderedList");
+    },
+    execute: (editor) => {
+      const { state } = editor;
+      const { selection } = state;
+      let chain = editor.chain().focus();
+      if (selection.node) {
+        const node = selection.node;
+        const firstChild = node.firstChild?.firstChild;
+        const lastChild = node.lastChild?.lastChild;
+        const from = firstChild ? selection.from + firstChild.nodeSize : selection.from + 1;
+        const to = lastChild ? selection.to - lastChild.nodeSize : selection.to - 1;
+        chain = chain.setTextSelection({ from, to }).clearNodes();
+      }
+      if (editor.isActive(listType)) {
+        return chain.liftListItem("listItem").lift("bulletList").lift("orderedList").selectTextblockEnd();
+      }
+      return chain[fnName]().selectTextblockEnd();
+    },
+    isActive: (editor) => editor.isActive(listType),
+    isDisabled: (editor) => isNodeTypeSelected(editor, ["image"]) || editor.isActive("code")
+  };
+}
+export function createMoveHandler(direction) {
+  return {
+    canExecute: (editor, cmd) => {
+      if (cmd?.pos == null) return false;
+      const node = editor.state.doc.nodeAt(cmd.pos);
+      if (!node) return false;
+      const $pos = editor.state.doc.resolve(cmd.pos);
+      const parent = $pos.parent;
+      const index = $pos.index();
+      return direction === "up" ? index > 0 : index < parent.childCount - 1;
+    },
+    execute: (editor, cmd) => {
+      if (cmd?.pos == null) return editor.chain();
+      const node = editor.state.doc.nodeAt(cmd.pos);
+      if (!node) return editor.chain();
+      const $pos = editor.state.doc.resolve(cmd.pos);
+      const parent = $pos.parent;
+      const index = $pos.index();
+      if (direction === "up" && index > 0) {
+        const prevNode = parent.child(index - 1);
+        const targetPos = cmd.pos - prevNode.nodeSize;
+        return editor.chain().focus().deleteRange({ from: cmd.pos, to: cmd.pos + node.nodeSize }).insertContentAt(targetPos, node.toJSON());
+      }
+      if (direction === "down" && index < parent.childCount - 1) {
+        const nextNode = parent.child(index + 1);
+        const targetPos = cmd.pos + nextNode.nodeSize;
+        return editor.chain().focus().deleteRange({ from: cmd.pos, to: cmd.pos + node.nodeSize }).insertContentAt(targetPos, node.toJSON());
+      }
+      return editor.chain();
+    },
+    isActive: () => false,
+    isDisabled: void 0
+  };
+}
+export function createHandlers() {
+  return {
+    mark: createMarkHandler(),
+    textAlign: createTextAlignHandler(),
+    heading: createHeadingHandler(),
+    link: createLinkHandler(),
+    image: createImageHandler(),
+    blockquote: createToggleHandler("blockquote"),
+    bulletList: createListHandler("bulletList"),
+    orderedList: createListHandler("orderedList"),
+    codeBlock: createToggleHandler("codeBlock"),
+    horizontalRule: createSetHandler("horizontalRule"),
+    paragraph: createSetHandler("paragraph"),
+    undo: createSimpleHandler("undo"),
+    redo: createSimpleHandler("redo"),
+    clearFormatting: {
+      canExecute: (editor, cmd) => {
+        if (cmd?.pos != null) {
+          const node = editor.state.doc.nodeAt(cmd.pos);
+          return !!node;
+        }
+        return editor.can().clearNodes() || editor.can().unsetAllMarks();
+      },
+      execute: (editor, cmd) => {
+        if (cmd?.pos != null) {
+          const node = editor.state.doc.nodeAt(cmd.pos);
+          if (!node) return editor.chain();
+          const from = cmd.pos + 1;
+          const to = cmd.pos + node.nodeSize - 1;
+          return editor.chain().focus().setTextSelection({ from, to }).clearNodes().unsetAllMarks();
+        }
+        return editor.chain().focus().clearNodes().unsetAllMarks();
+      },
+      isActive: () => false,
+      isDisabled: void 0
+    },
+    duplicate: {
+      canExecute: (editor, cmd) => {
+        if (cmd?.pos == null) return false;
+        const node = editor.state.doc.nodeAt(cmd.pos);
+        return !!node;
+      },
+      execute: (editor, cmd) => {
+        if (cmd?.pos == null) return editor.chain();
+        const node = editor.state.doc.nodeAt(cmd.pos);
+        if (!node) return editor.chain();
+        return editor.chain().focus().insertContentAt(cmd.pos + node.nodeSize, node.toJSON());
+      },
+      isActive: () => false,
+      isDisabled: void 0
+    },
+    delete: {
+      canExecute: (editor, cmd) => {
+        if (cmd?.pos == null) return false;
+        const node = editor.state.doc.nodeAt(cmd.pos);
+        return !!node;
+      },
+      execute: (editor, cmd) => {
+        if (cmd?.pos == null) return editor.chain();
+        const node = editor.state.doc.nodeAt(cmd.pos);
+        if (!node) return editor.chain();
+        return editor.chain().focus().deleteRange({ from: cmd.pos, to: cmd.pos + node.nodeSize });
+      },
+      isActive: () => false,
+      isDisabled: void 0
+    },
+    moveUp: createMoveHandler("up"),
+    moveDown: createMoveHandler("down"),
+    suggestion: {
+      canExecute: () => true,
+      execute: (editor, cmd) => {
+        const { state } = editor;
+        const { selection } = state;
+        const { $from } = selection;
+        if (cmd?.pos !== void 0) {
+          const node = state.doc.nodeAt(cmd.pos);
+          if (node) {
+            const insertPos2 = cmd.pos + node.nodeSize;
+            return editor.chain().focus().insertContentAt(insertPos2, { type: "paragraph", content: [{ type: "text", text: "/" }] });
+          }
+        }
+        const currentNode = $from.node($from.depth);
+        const currentNodePos = $from.before($from.depth);
+        const insertPos = currentNodePos + currentNode.nodeSize;
+        return editor.chain().focus().insertContentAt(insertPos, { type: "paragraph", content: [{ type: "text", text: "/" }] });
+      },
+      isActive: () => false,
+      isDisabled: void 0
+    },
+    mention: {
+      canExecute: () => true,
+      execute: (editor) => {
+        const { state } = editor;
+        const { selection } = state;
+        const { $from } = selection;
+        const textBefore = $from.parent.textBetween(Math.max(0, $from.parentOffset - 1), $from.parentOffset, void 0, " ");
+        const needsSpace = textBefore && textBefore !== " ";
+        return editor.chain().focus().insertContent(needsSpace ? " @" : "@");
+      },
+      isActive: () => false,
+      isDisabled: void 0
+    },
+    emoji: {
+      canExecute: () => true,
+      execute: (editor) => {
+        const { state } = editor;
+        const { selection } = state;
+        const { $from } = selection;
+        const textBefore = $from.parent.textBetween(Math.max(0, $from.parentOffset - 1), $from.parentOffset, void 0, " ");
+        const needsSpace = textBefore && textBefore !== " ";
+        return editor.chain().focus().insertContent(needsSpace ? " :" : ":");
+      },
+      isActive: () => false,
+      isDisabled: void 0
+    }
+  };
+}
+export function mapEditorItems(editor, items, customHandlers) {
+  const handlers = { ...createHandlers(), ...customHandlers };
+  if (isArrayOfArray(items)) {
+    return items.map(
+      (group) => mapEditorItems(editor, group, customHandlers)
+    );
+  }
+  return items.filter(Boolean).map((item) => {
+    if ("type" in item) {
+      return item;
+    }
+    const { kind, children, ...rest } = item;
+    const processedChildren = children?.length ? mapEditorItems(editor, children, customHandlers) : void 0;
+    if (kind) {
+      const handler = handlers[kind];
+      if (!handler) {
+        return {
+          ...rest,
+          children: processedChildren
+        };
+      }
+      return {
+        ...rest,
+        children: processedChildren,
+        disabled: handler.isDisabled?.(editor, item) || !handler.canExecute(editor, item),
+        active: handler.isActive(editor, item),
+        onSelect: () => handler.execute(editor, item).run()
+      };
+    }
+    return { ...rest, children: processedChildren };
+  });
+}
+export function buildFloatingUIMiddleware(options) {
+  const middleware = [];
+  if (options.offset) {
+    middleware.push(offset(typeof options.offset !== "boolean" ? options.offset : void 0));
+  }
+  if (options.flip) {
+    middleware.push(flip(typeof options.flip !== "boolean" ? options.flip : void 0));
+  }
+  if (options.shift) {
+    middleware.push(shift(typeof options.shift !== "boolean" ? options.shift : void 0));
+  }
+  if (options.size) {
+    middleware.push(size(typeof options.size !== "boolean" ? options.size : void 0));
+  }
+  if (options.autoPlacement) {
+    middleware.push(autoPlacement(typeof options.autoPlacement !== "boolean" ? options.autoPlacement : void 0));
+  }
+  if (options.hide) {
+    middleware.push(hide(typeof options.hide !== "boolean" ? options.hide : void 0));
+  }
+  if (options.inline) {
+    middleware.push(inline(typeof options.inline !== "boolean" ? options.inline : void 0));
+  }
+  return middleware;
+}

package/dist/runtime/vue/components/color-mode/ColorModeSelect.vue

@@ -33,6 +33,7 @@ const props = defineProps({
   labelKey: { type: null, required: false },
   descriptionKey: { type: null, required: false },
   defaultValue: { type: null, required: false },
+  modelModifiers: { type: Object, required: false },
   multiple: { type: Boolean, required: false },
   highlight: { type: Boolean, required: false },
   createItem: { type: [Boolean, String, Object], required: false },

package/dist/shared/{b24ui-nuxt.BCphUjPy.mjs → b24ui-nuxt.C8MyFqPm.mjs}

@@ -8,7 +8,7 @@ import { globSync } from 'tinyglobby';
 import { defuFn } from 'defu';
 
 const name = "@bitrix24/b24ui-nuxt";
-const version = "2.1.10";
+const version = "2.1.12";
 
 function getDefaultConfig(theme) {
   return {
@@ -3035,6 +3035,182 @@ const dropdownMenu = {
   defaultVariants: {}
 };
 
+const editor = {
+  slots: {
+    root: "light",
+    content: "relative size-full flex-1",
+    base: [
+      "w-full outline-none *:my-5 *:first:mt-0 *:last:mb-0 sm:px-8 selection:bg-(--ui-color-design-selection-bg)",
+      // Placeholder
+      "[&_:is(p,h1,h2,h3,h4).is-empty]:before:content-[attr(data-placeholder)] [&_:is(p,h1,h2,h3,h4).is-empty]:before:text-(--b24ui-typography-label-color) [&_:is(p,h1,h2,h3,h4).is-empty]:before:float-left [&_:is(p,h1,h2,h3,h4).is-empty]:before:h-0 [&_:is(p,h1,h2,h3,h4).is-empty]:before:pointer-events-none",
+      "[&_li_.is-empty]:before:content-none",
+      // Paragraph
+      "[&_p]:leading-7",
+      // Links
+      "[&_a]:text-(--ui-color-accent-main-primary) [&_a]:border-b [&_a]:border-transparent [&_a]:hover:border-(--ui-color-accent-main-primary) [&_a]:font-(--ui-font-weight-medium)",
+      "[&_a]:transition-colors",
+      // Mentions
+      "[&_.mention]:text-(--ui-color-accent-main-primary) [&_.mention]:font-(--ui-font-weight-medium)",
+      // Headings - shared styles
+      "[&_:is(h1,h2,h3,h4)]:text-(--b24ui-typography-label-color) [&_:is(h1,h2,h3,h4)]:font-(--ui-font-weight-bold)",
+      // Headings - unique styles
+      "[&_h1]:text-3xl",
+      "[&_h2]:text-2xl",
+      "[&_h3]:text-xl",
+      "[&_h4]:text-lg",
+      // Code inside headings
+      "[&_:is(h1,h2,h3,h4)>code]:border-dashed [&_:is(h1,h2,h3,h4)>code]:font-(--ui-font-weight-bold)",
+      "[&_h2>code]:text-xl/6",
+      "[&_h3>code]:text-lg/5",
+      // Blockquote & HR
+      "[&_blockquote]:border-s-4 [&_blockquote]:border-(--ui-color-accent-soft-element-blue) [&_blockquote]:ps-4 [&_blockquote]:italic",
+      "[&_[data-type=horizontalRule]]:my-8 [&_[data-type=horizontalRule]]:py-2",
+      "[&_hr]:border-t [&_hr]:border-(--ui-color-divider-default)",
+      // Code blocks
+      "[&_pre]:text-sm/6 [&_pre]:border [&_pre]:border-(--ui-color-design-tinted-na-stroke) [&_pre]:bg-(--ui-color-design-tinted-na-bg) [&_pre]:rounded-md [&_pre]:px-4 [&_pre]:py-3 [&_pre]:whitespace-pre-wrap [&_pre]:break-words [&_pre]:overflow-x-auto",
+      "[&_pre_code]:p-0 [&_pre_code]:text-inherit [&_pre_code]:font-inherit [&_pre_code]:rounded-none [&_pre_code]:inline [&_pre_code]:border-0 [&_pre_code]:bg-transparent",
+      // Inline code
+      "[&_code]:px-1.5 [&_code]:py-0.5 [&_code]:text-sm [&_code]:font-[family-name:var(--ui-font-family-system-mono)] [&_code]:font-(--ui-font-weight-medium) [&_code]:rounded-md [&_code]:inline-block [&_code]:border [&_code]:border-(--ui-color-design-tinted-na-stroke) [&_code]:text-(--b24ui-typography-label-color) [&_code]:bg-(--ui-color-design-tinted-na-bg)",
+      // Lists
+      "[&_:is(ul,ol)]:ps-6",
+      "[&_ul]:list-disc [&_ul]:marker:text-(--ui-color-accent-soft-element-blue)",
+      "[&_ol]:list-decimal [&_ol]:marker:text-(--b24ui-typography-label-color)",
+      "[&_li]:my-1.5 [&_li]:ps-1.5",
+      // Images
+      "[&_img]:rounded-md [&_img]:block [&_img]:max-w-full [&_img.ProseMirror-selectednode]:outline-2 [&_img.ProseMirror-selectednode]:outline-(--ui-color-accent-main-primary)",
+      // Selected nodes
+      "[&_.ProseMirror-selectednode:not(img):not(pre):not([data-node-view-wrapper])]:bg-(--ui-color-design-selection-bg)"
+    ].join(" ")
+  }
+};
+
+const editorDragHandle = {
+  slots: {
+    root: "hidden sm:flex items-center justify-center transition-all duration-200 ease-out",
+    handle: "cursor-grab px-1"
+  }
+};
+
+const editorSuggestionMenu = {
+  slots: {
+    content: [
+      "light",
+      "bg-(--popup-window-background-color)",
+      "shadow-(--popup-window-box-shadow)",
+      "rounded-(--popup-window-border-radius) will-change-[opacity]",
+      "motion-safe:data-[state=open]:animate-[scale-in_100ms_ease-out] motion-safe:data-[state=closed]:animate-[scale-out_100ms_ease-in]",
+      "origin-(--reka-dropdown-menu-content-transform-origin)",
+      "font-[family-name:var(--ui-font-family-primary)]",
+      "relative",
+      "isolate",
+      "px-0 py-(--menu-popup-padding)",
+      "pointer-events-auto"
+    ].join(" "),
+    viewport: [
+      "relative",
+      "w-full max-h-[40vh] min-w-[120px] max-w-[192px]",
+      "overflow-x-hidden overflow-y-auto scrollbar-thin"
+      // scrollbar-transparent
+    ].join(" "),
+    group: "grid",
+    // p-1 isolate
+    label: [
+      "w-full h-(--popup-window-delimiter-section-height)",
+      // min-w-[195px]
+      "px-[18px] mt-(--menu-item-block-stack-space)",
+      "flex flex-row rtl:flex-row-reverse items-center",
+      "select-none outline-none whitespace-nowrap",
+      "text-start",
+      "text-(length:--popup-window-delimiter-font-size)",
+      "text-(--popup-window-delimiter-text-color)",
+      "font-(--popup-window-delimiter-font-weight)",
+      "after:ms-[10px] after:block after:flex-1 after:min-w-[15px] after:h-px after:bg-(--popup-window-delimiter-bg-color)"
+    ].join(" "),
+    item: [
+      "group",
+      "w-full h-[36px]",
+      // min-w-[195px]
+      "px-[18px] mt-(--menu-item-block-stack-space)",
+      "relative",
+      "flex flex-row rtl:flex-row-reverse items-center",
+      "select-none outline-none whitespace-nowrap",
+      "cursor-pointer",
+      "data-disabled:cursor-not-allowed data-disabled:opacity-30",
+      "text-start",
+      "text-(length:--menu-popup-item-font-size)",
+      "text-(--menu-popup-item-color) hover:text-(--menu-popup-item-color-hover)",
+      "data-highlighted:text-(--menu-popup-item-color-hover)",
+      "data-[state=open]:text-(--menu-popup-item-color-hover)",
+      "hover:bg-(--menu-popup-item-bg-color-hover)",
+      "data-highlighted:bg-(--menu-popup-item-bg-color-hover)",
+      "data-[state=open]:bg-(--menu-popup-item-bg-color-hover)",
+      "transition-colors"
+    ].join(" "),
+    itemLeadingIcon: [
+      "shrink-0",
+      "size-[18px]",
+      "text-(--ui-color-design-plain-content-icon-secondary)",
+      "group-data-highlighted:text-(--ui-color-accent-main-primary)",
+      "group-data-[state=open]:text-(--ui-color-accent-main-primary)",
+      "group-data-[state=checked]:text-(--ui-color-accent-main-primary)",
+      "transition-colors"
+    ].join(" "),
+    itemLeadingAvatar: "shrink-0 size-[16px] me-[8px]",
+    // @memo 18-2px
+    itemLeadingAvatarSize: "2xs",
+    // @memo this wrong
+    itemWrapper: "ms-[4px] flex-1 flex flex-col text-start min-w-0",
+    itemLabel: [
+      "max-w-[240px] truncate -mt-px",
+      "group-data-[state=checked]:text-(--ui-color-accent-main-primary)"
+    ].join(" "),
+    itemDescription: "max-w-[240px] truncate -mt-[6px] text-(--b24ui-typography-description-color) text-(length:--ui-font-size-sm)",
+    itemLabelExternalIcon: "inline-block size-[16px] text-(--ui-color-design-plain-content-icon-secondary)"
+  },
+  variants: {
+    active: {
+      true: {
+        item: [
+          "text-(--ui-color-accent-main-primary)",
+          "hover:text-(--ui-color-accent-main-primary)"
+        ].join(" "),
+        itemLeadingIcon: [
+          "text-(--ui-color-accent-main-primary)",
+          "hover:text-(--ui-color-accent-main-primary)",
+          "group-data-[state=open]:text-(--ui-color-accent-main-primary)"
+        ].join(" ")
+      },
+      false: {}
+    }
+  }
+};
+
+const editorEmojiMenu = () => editorSuggestionMenu;
+
+const editorMentionMenu = () => editorSuggestionMenu;
+
+const editorToolbar = {
+  slots: {
+    root: "focus:outline-none",
+    base: "flex items-stretch gap-1.5",
+    group: "flex items-center gap-0.5",
+    separator: "w-px self-stretch bg-(--ui-color-design-tinted-na-stroke)"
+  },
+  variants: {
+    layout: {
+      bubble: {
+        base: "bg-(--popup-window-background-color) border border-(--ui-color-divider-default) rounded-md p-1"
+      },
+      floating: {
+        base: "bg-(--popup-window-background-color) border border-(--ui-color-divider-default) rounded-md p-1"
+      },
+      fixed: {
+        base: ""
+      }
+    }
+  }
+};
+
 const empty = {
   slots: {
     root: [
@@ -3836,6 +4012,7 @@ const inputDate = () => {
       separatorIcon: "shrink-0 size-4 text-(--ui-color-base-6)"
     },
     variants: {
+      ...fieldGroupVariant,
       size: {
         xss: {
           base: (prev) => [prev, "gap-0.20", "px-1"].join(" "),
@@ -4890,6 +5067,7 @@ const inputTime = () => {
       ].join(" ")
     },
     variants: {
+      ...fieldGroupVariant,
       size: {
         xss: {
           base: (prev) => [prev, "gap-0.20", "px-1"].join(" "),
@@ -9175,6 +9353,12 @@ const theme = {
   dashboardSearchButton: dashboardSearchButton,
   descriptionList: descriptionList,
   dropdownMenu: dropdownMenu,
+  editor: editor,
+  editorDragHandle: editorDragHandle,
+  editorEmojiMenu: editorEmojiMenu,
+  editorMentionMenu: editorMentionMenu,
+  editorSuggestionMenu: editorSuggestionMenu,
+  editorToolbar: editorToolbar,
   empty: empty,
   error: error,
   fieldGroup: fieldGroup$1,

package/dist/unplugin.mjs

@@ -3,7 +3,7 @@ import { join, normalize } from 'pathe';
 import { createUnplugin } from 'unplugin';
 import { defu } from 'defu';
 import tailwind from '@tailwindcss/vite';
-import { g as getTemplates, d as defaultOptions, a as getDefaultConfig } from './shared/b24ui-nuxt.BCphUjPy.mjs';
+import { g as getTemplates, d as defaultOptions, a as getDefaultConfig } from './shared/b24ui-nuxt.C8MyFqPm.mjs';
 import fs from 'node:fs';
 import path from 'node:path';
 import MagicString from 'magic-string';

package/dist/vite.mjs

@@ -4,7 +4,7 @@ import 'pathe';
 import 'unplugin';
 import 'defu';
 import '@tailwindcss/vite';
-import './shared/b24ui-nuxt.BCphUjPy.mjs';
+import './shared/b24ui-nuxt.C8MyFqPm.mjs';
 import 'scule';
 import 'knitwork';
 import '@nuxt/kit';

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@bitrix24/b24ui-nuxt",
   "description": "Bitrix24 UI-Kit for developing web applications REST API for NUXT & VUE",
-  "version": "2.1.10",
+  "version": "2.1.12",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/bitrix24/b24ui.git"
@@ -118,6 +118,19 @@
     "@tailwindcss/vite": "^4.1.17",
     "@tanstack/vue-table": "^8.21.3",
     "@tanstack/vue-virtual": "^3.13.12",
+    "@tiptap/core": "3.13.0",
+    "@tiptap/extension-bubble-menu": "3.13.0",
+    "@tiptap/extension-drag-handle-vue-3": "3.13.0",
+    "@tiptap/extension-floating-menu": "3.13.0",
+    "@tiptap/extension-horizontal-rule": "3.13.0",
+    "@tiptap/extension-image": "3.13.0",
+    "@tiptap/extension-mention": "3.13.0",
+    "@tiptap/extension-placeholder": "3.13.0",
+    "@tiptap/markdown": "3.13.0",
+    "@tiptap/pm": "3.13.0",
+    "@tiptap/starter-kit": "3.13.0",
+    "@tiptap/suggestion": "3.13.0",
+    "@tiptap/vue-3": "3.13.0",
     "@unhead/vue": "^2.0.19",
     "@vueuse/core": "^14.1.0",
     "@vueuse/integrations": "^14.1.0",
@@ -155,14 +168,14 @@
   "devDependencies": {
     "@nuxt/eslint-config": "^1.11.0",
     "@nuxt/module-builder": "^1.0.2",
-    "@nuxt/test-utils": "^3.20.1",
+    "@nuxt/test-utils": "^3.21.0",
     "@types/canvas-confetti": "^1.9.0",
     "@types/node": "^24.7.0",
     "esno": "^4.8.0",
     "nuxt-component-meta": "^0.14.2",
     "sharp": "^0.34.3",
     "@vue/test-utils": "^2.4.6",
-    "ai": "^5.0.105",
+    "ai": "^5.0.108",
     "embla-carousel": "^8.6.0",
     "eslint": "^9.39.1",
     "happy-dom": "^20.0.11",