@antscorp/antsomi-ui 2.0.110 → 2.0.112

package/es/components/organism/TextEditor/utils/htmlProcessing.js

@@ -0,0 +1,460 @@
+import { isEmpty } from 'lodash';
+import { textStyleFromElStyle, appendTextStyleToEl } from './style';
+import tinycolor from 'tinycolor2';
+const SMART_TAG_HIGHLIGHT_BG = 'rgba(0, 199, 97, 0.2)'; // old texteditor (floara version)
+/**
+ * Creates a clean span element for a dynamic tag with only the essential attributes
+ *
+ * @param doc - The document used to create the new element
+ * @param originalSpan - The original dynamic tag span element
+ * @param attributesToPreserve - List of attribute names to copy from the original span
+ * @returns A new span element with preserved attributes
+ */
+function createCleanDynamicSpan(doc, originalSpan, attributesToPreserve) {
+    const cleanSpan = doc.createElement('span');
+    // Preserve only the specified attributes
+    for (const attrName of attributesToPreserve) {
+        if (originalSpan.hasAttribute(attrName)) {
+            cleanSpan.setAttribute(attrName, originalSpan.getAttribute(attrName));
+        }
+    }
+    // Preserve the text content
+    cleanSpan.textContent = originalSpan.textContent?.trim() || '';
+    return cleanSpan;
+}
+/**
+ * Extracts style wrapper elements that need to be preserved from the original dynamic tag
+ *
+ * @param doc - The document containing the dynamic tag
+ * @param html - The original HTML string
+ * @param dynamicSpan - The original dynamic tag span element
+ * @param wrapperElement - Optional wrapper element to use instead of document.body
+ * @returns Array of wrapper elements that provide styling
+ */
+function extractStyleWrappers(params) {
+    const { doc, html, dynamicSpan, wrapperElement, defaultStyle } = params;
+    const styleWrappers = [];
+    // Create a temporary container for style computation
+    const tempStyleContainer = document.createElement('div');
+    tempStyleContainer.style.display = 'none';
+    const targetWrapper = wrapperElement || document.body;
+    targetWrapper.appendChild(tempStyleContainer);
+    try {
+        // Extract computed styles from the original element
+        if (doc.body.firstElementChild) {
+            const tempDoc = new DOMParser().parseFromString(html, 'text/html');
+            if (tempDoc.body.firstElementChild) {
+                tempStyleContainer.appendChild(tempDoc.body.firstElementChild);
+                const originalDynamicElement = tempStyleContainer.querySelector(`span[data-dynamic-id="${dynamicSpan.dataset.dynamicId}"]`);
+                if (originalDynamicElement) {
+                    // Create a span with the computed text styles
+                    const computedTextStyle = textStyleFromElStyle(window.getComputedStyle(originalDynamicElement), defaultStyle);
+                    // Remove background color if it matches the highlight color
+                    if (tinycolor.equals(computedTextStyle.backgroundColor, SMART_TAG_HIGHLIGHT_BG)) {
+                        computedTextStyle.backgroundColor = '';
+                    }
+                    const textStyleWrapper = document.createElement('span');
+                    appendTextStyleToEl(textStyleWrapper, computedTextStyle);
+                    styleWrappers.push(textStyleWrapper);
+                }
+            }
+        }
+        // Extract nested style wrappers
+        let nestedElement = dynamicSpan.firstElementChild;
+        while (nestedElement && nestedElement.children.length <= 1) {
+            styleWrappers.push(nestedElement);
+            nestedElement = nestedElement.firstElementChild || null;
+        }
+        return styleWrappers;
+    }
+    finally {
+        // Clean up the temporary container
+        targetWrapper.removeChild(tempStyleContainer);
+    }
+}
+/**
+ * Reconstructs the dynamic tag element hierarchy with preserved style wrappers
+ *
+ * @param doc - The document used to create new elements
+ * @param baseSpan - The clean base span element for the dynamic tag
+ * @param styleWrappers - Array of style wrapper elements to apply
+ * @returns The reconstructed dynamic tag with preserved styling
+ */
+function reconstructDynamicTagHierarchy(doc, baseSpan, styleWrappers) {
+    let resultNode = baseSpan;
+    // Apply style wrappers from innermost to outermost
+    styleWrappers.reverse().forEach(originalWrapper => {
+        const wrapperClone = doc.createElement(originalWrapper.tagName.toLowerCase());
+        // Clone all attributes from the original wrapper
+        for (let i = 0; i < originalWrapper.attributes.length; i++) {
+            const { name, value } = originalWrapper.attributes[i];
+            wrapperClone.setAttribute(name, value);
+        }
+        wrapperClone.appendChild(resultNode);
+        resultNode = wrapperClone;
+    });
+    return resultNode;
+}
+/**
+ * Restructures dynamic tags from Froala editor format to be compatible with Tiptap editor.
+ * This function preserves styling and attributes of dynamic tags while cleaning up their structure.
+ *
+ * @param html - The HTML string containing dynamic tags
+ * @param options - Configuration options for the restructuring process
+ * @param wrapperElement - Optional wrapper element to use instead of document.body
+ * @returns The restructured HTML string
+ */
+export function restructureDynamicTagsWithOptions(params) {
+    const { html, options = {
+        attributesToClone: [
+            'class',
+            'id',
+            'style',
+            'data-dynamic',
+            'data-dynamic-id',
+            'direction',
+            'unicode-bidi',
+            'text-align',
+            'background-color',
+            'color',
+        ],
+    }, wrapperElement, defaultStyle, } = params;
+    // Parse the HTML string into a DOM
+    const parser = new DOMParser();
+    const parsedDoc = parser.parseFromString(html, 'text/html');
+    // Find all dynamic tag spans
+    const dynamicTagSpans = parsedDoc.querySelectorAll('span[data-dynamic]');
+    // Process each dynamic span
+    dynamicTagSpans.forEach(originalDynamicSpan => {
+        // Step 1: Create a new clean span with essential attributes
+        const cleanDynamicSpan = createCleanDynamicSpan(parsedDoc, originalDynamicSpan, options.attributesToClone);
+        // Step 2: Extract style wrappers that need to be preserved
+        const styleWrappers = extractStyleWrappers({
+            doc: parsedDoc,
+            html,
+            dynamicSpan: originalDynamicSpan,
+            wrapperElement,
+            defaultStyle,
+        });
+        // Step 3: Reconstruct the element hierarchy with preserved styles
+        const restructuredDynamicTag = reconstructDynamicTagHierarchy(parsedDoc, cleanDynamicSpan, styleWrappers);
+        // Step 4: Replace the original span with the restructured node
+        originalDynamicSpan.replaceWith(restructuredDynamicTag);
+    });
+    return parsedDoc.body.innerHTML;
+}
+/**
+ * Converts inherited text styles to computed styles for span elements in HTML content.
+ * This function processes span elements to ensure text styles are explicitly set rather than inherited.
+ *
+ * @param html - The HTML string to process
+ * @param wrapperElement - Optional wrapper element to use instead of document.body
+ * @returns The processed HTML string with computed styles applied
+ */
+const inheritStyleToComputedStyle = (params) => {
+    const { html, wrapperElement, defaultStyle } = params;
+    try {
+        // Create a new DOM parser and parse the HTML
+        const parser = new DOMParser();
+        const doc = parser.parseFromString(html, 'text/html');
+        if (!doc.body) {
+            // eslint-disable-next-line no-console
+            console.warn('Failed to parse HTML: body not found');
+            return html;
+        }
+        // Create a hidden container
+        const container = document.createElement('div');
+        container.style.visibility = 'hidden';
+        container.innerHTML = doc.body.innerHTML;
+        // Add container to DOM temporarily to compute styles
+        const targetWrapper = wrapperElement || document.body;
+        targetWrapper.appendChild(container);
+        // Process all span elements
+        const spanElements = container.querySelectorAll('span');
+        spanElements.forEach(span => {
+            const textStyle = textStyleFromElStyle(span.style, defaultStyle);
+            const computedStyle = window.getComputedStyle(span);
+            // Only update styles if there are inherited values
+            const shouldUpdateStyle = Object.values(textStyle).some(value => value === 'inherit');
+            if (!shouldUpdateStyle) {
+                return;
+            }
+            // Update inherited styles with computed values
+            Object.entries(textStyle).forEach(([key, value]) => {
+                if (value === 'inherit' && key in span.style) {
+                    span.style[key] = computedStyle[key];
+                }
+            });
+        });
+        const resultHTML = container.innerHTML;
+        // Clean up
+        container.remove();
+        return resultHTML;
+    }
+    catch (error) {
+        // eslint-disable-next-line no-console
+        console.error('Error processing styles:', error);
+        return html; // Return original HTML in case of error
+    }
+};
+/**
+ * Removes empty paragraphs and spans with only break lines.
+ * @param html - The HTML string to process
+ * @returns The processed HTML string
+ */
+export function cleanLineBreaks(html) {
+    try {
+        const parser = new DOMParser();
+        const doc = parser.parseFromString(html, 'text/html');
+        const allSpans = doc.body.querySelectorAll('span');
+        const paragraphs = doc.body.querySelectorAll('p');
+        paragraphs.forEach(paragraph => {
+            const paragraphText = paragraph.textContent;
+            const breakLines = paragraph.querySelectorAll('br');
+            if (isEmpty(paragraphText) && isEmpty(breakLines)) {
+                paragraph.remove();
+            }
+            else if (isEmpty(paragraphText)) {
+                breakLines.forEach(breakLine => {
+                    breakLine.remove();
+                });
+            }
+        });
+        allSpans.forEach(span => {
+            const spanText = span.textContent;
+            const breakLines = span.querySelectorAll('br');
+            if (isEmpty(spanText) && breakLines.length > 0) {
+                breakLines.forEach(breakLine => {
+                    breakLine.remove();
+                });
+            }
+        });
+        return doc.body.innerHTML;
+    }
+    catch (error) {
+        // eslint-disable-next-line no-console
+        console.error('Error cleaning line breaks:', error);
+        return html;
+    }
+}
+/**
+ * Swaps the structure when a dynamic tag contains only a single link.
+ * Changes from: <span data-dynamic><a>text</a></span>
+ * To: <a><span data-dynamic>text</span></a>
+ *
+ * @param html - HTML string to process
+ * @returns Processed HTML string with swapped structure
+ */
+function swapDynamicTagWithLink(html) {
+    try {
+        const parser = new DOMParser();
+        const doc = parser.parseFromString(html, 'text/html');
+        // Find all dynamic tag spans
+        const dynamicSpans = doc.querySelectorAll('span[data-dynamic="true"]');
+        dynamicSpans.forEach(dynamicSpan => {
+            // Get all child nodes (elements and text nodes)
+            const childNodes = Array.from(dynamicSpan.childNodes);
+            // Filter out empty text nodes (whitespace only)
+            const nonEmptyNodes = childNodes.filter(node => {
+                if (node.nodeType === Node.TEXT_NODE) {
+                    return node.textContent?.trim() !== '';
+                }
+                return true;
+            });
+            // Check if there's exactly one child and it's an <a> element
+            if (nonEmptyNodes.length === 1 && nonEmptyNodes[0].nodeType === Node.ELEMENT_NODE) {
+                const childElement = nonEmptyNodes[0];
+                if (childElement instanceof HTMLElement && childElement.tagName.toLowerCase() === 'a') {
+                    const linkElement = childElement;
+                    // Create new span with dynamic attributes
+                    const newSpan = doc.createElement('span');
+                    // Copy all attributes from original dynamic span
+                    Array.from(dynamicSpan.attributes).forEach(attr => {
+                        newSpan.setAttribute(attr.name, attr.value);
+                    });
+                    // Set the text content from the link
+                    newSpan.textContent = linkElement.textContent;
+                    // Create new link element
+                    const newLink = doc.createElement('a');
+                    // Copy all attributes from original link
+                    Array.from(linkElement.attributes).forEach(attr => {
+                        newLink.setAttribute(attr.name, attr.value);
+                    });
+                    // Put span inside link
+                    newLink.appendChild(newSpan);
+                    // Replace original dynamic span with the new link
+                    dynamicSpan.replaceWith(newLink);
+                }
+            }
+        });
+        return doc.body.innerHTML;
+    }
+    catch (error) {
+        // eslint-disable-next-line no-console
+        console.error('Error swapping dynamic tag with link:', error);
+        return html; // Return original HTML in case of error
+    }
+}
+/**
+ * Safely parses and processes HTML content for editor use
+ * @param html - HTML string to process
+ * @param wrapperElement - Optional wrapper element to use instead of document.body for temporary DOM operations
+ * @returns Processed HTML string
+ */
+export function safeParseHTMLContent(params) {
+    const { html, wrapperElement, defaultStyle } = params;
+    let resultHTML = html;
+    resultHTML = cleanLineBreaks(resultHTML);
+    const isFroala = html.includes('fr-box') || html.includes('fr-tag');
+    if (isFroala) {
+        resultHTML = inheritStyleToComputedStyle({
+            html,
+            wrapperElement,
+            defaultStyle,
+        });
+        resultHTML = restructureDynamicTagsWithOptions({
+            html: resultHTML,
+            wrapperElement,
+            defaultStyle,
+        });
+    }
+    // Swap dynamic tag structure when it contains only a link
+    resultHTML = swapDynamicTagWithLink(resultHTML);
+    // console.log('after safeParseHTMLContent', resultHTML);
+    return resultHTML;
+}
+/**
+ * Sanitizes HTML by removing potentially dangerous elements and attributes
+ * @param html - HTML string to sanitize
+ * @returns Sanitized HTML string
+ */
+export function sanitizeHTML(html) {
+    const parser = new DOMParser();
+    const doc = parser.parseFromString(html, 'text/html');
+    // Remove script tags
+    const scripts = doc.querySelectorAll('script');
+    scripts.forEach(script => script.remove());
+    // Remove on* event attributes
+    const allElements = doc.querySelectorAll('*');
+    allElements.forEach(element => {
+        Array.from(element.attributes).forEach(attr => {
+            if (attr.name.startsWith('on')) {
+                element.removeAttribute(attr.name);
+            }
+        });
+    });
+    return doc.body.innerHTML;
+}
+/**
+ * Extracts text content from HTML
+ * @param html - HTML string
+ * @returns Plain text content
+ */
+export function extractTextFromHTML(html) {
+    const parser = new DOMParser();
+    const doc = parser.parseFromString(html, 'text/html');
+    return doc.body.textContent || '';
+}
+/**
+ * Counts words in HTML content
+ * @param html - HTML string
+ * @returns Word count
+ */
+export function countWordsInHTML(html) {
+    const text = extractTextFromHTML(html);
+    return text
+        .trim()
+        .split(/\s+/)
+        .filter(word => word.length > 0).length;
+}
+/**
+ * Counts characters in HTML content
+ * @param html - HTML string
+ * @param includeSpaces - Whether to include spaces in count
+ * @returns Character count
+ */
+export function countCharactersInHTML(html, includeSpaces = true) {
+    const text = extractTextFromHTML(html);
+    return includeSpaces ? text.length : text.replace(/\s/g, '').length;
+}
+/**
+ * Wraps text nodes with specified tag
+ * @param html - HTML string
+ * @param tagName - Tag name to wrap with
+ * @param className - Optional class name for wrapper
+ * @returns HTML with wrapped text nodes
+ */
+export function wrapTextNodes(html, tagName = 'span', className) {
+    const parser = new DOMParser();
+    const doc = parser.parseFromString(html, 'text/html');
+    function wrapTextNodesRecursive(node) {
+        if (node.nodeType === Node.TEXT_NODE && node.textContent?.trim()) {
+            const wrapper = doc.createElement(tagName);
+            if (className) {
+                wrapper.className = className;
+            }
+            wrapper.textContent = node.textContent;
+            node.parentNode?.replaceChild(wrapper, node);
+        }
+        else {
+            Array.from(node.childNodes).forEach(wrapTextNodesRecursive);
+        }
+    }
+    wrapTextNodesRecursive(doc.body);
+    return doc.body.innerHTML;
+}
+/**
+ * Removes empty elements from HTML
+ * @param html - HTML string
+ * @returns HTML with empty elements removed
+ */
+export function removeEmptyElements(html) {
+    const parser = new DOMParser();
+    const doc = parser.parseFromString(html, 'text/html');
+    function removeEmptyRecursive(node) {
+        Array.from(node.children).forEach(child => {
+            removeEmptyRecursive(child);
+            if (!child.textContent?.trim() && child.children.length === 0) {
+                child.remove();
+            }
+        });
+    }
+    removeEmptyRecursive(doc.body);
+    return doc.body.innerHTML;
+}
+/**
+ * Normalizes whitespace in HTML
+ * @param html - HTML string
+ * @returns HTML with normalized whitespace
+ */
+export function normalizeWhitespace(html) {
+    return html.replace(/\s+/g, ' ').replace(/>\s+</g, '><').trim();
+}
+export const htmlMinifyForEmail = (htmlEditorContent) => {
+    const parser = new DOMParser();
+    const doc = parser.parseFromString(htmlEditorContent, 'text/html');
+    const allElements = doc.body.querySelectorAll('*');
+    allElements.forEach(element => {
+        element.removeAttribute('spellcheck');
+        element.removeAttribute('class');
+        element.removeAttribute('contenteditable');
+    });
+    return doc.body.innerHTML;
+};
+/**
+ * Serializes HTML for output
+ * @param htmlEditorContent - HTML string to serialize
+ * @returns Serialized HTML string
+ */
+export const htmlSerializerForOutput = (htmlEditorContent) => {
+    const parser = new DOMParser();
+    const doc = parser.parseFromString(htmlEditorContent, 'text/html');
+    const paragraphs = doc.body.querySelectorAll('p');
+    paragraphs.forEach(paragraph => {
+        if (paragraph.innerHTML?.trim() === '') {
+            const br = doc.createElement('br');
+            paragraph.appendChild(br);
+        }
+    });
+    return doc.body.innerHTML;
+};

package/es/components/organism/TextEditor/utils/indent.d.ts

@@ -0,0 +1,11 @@
+import type { Command } from '@tiptap/core';
+export declare const enum IndentProps {
+    max = 7,
+    min = 0,
+    more = 1,
+    less = -1
+}
+export declare function createIndentCommand({ delta, types }: {
+    delta: number;
+    types: string[];
+}): Command;

package/es/components/organism/TextEditor/utils/indent.js

@@ -0,0 +1,56 @@
+import { isList } from '@tiptap/core';
+import { TextSelection, AllSelection } from '@tiptap/pm/state';
+import { clamp } from './shared';
+function setNodeIndentMarkup(tr, pos, delta) {
+    if (!tr.doc)
+        return tr;
+    const node = tr.doc.nodeAt(pos);
+    if (!node)
+        return tr;
+    const minIndent = 0 /* IndentProps.min */;
+    const maxIndent = 7 /* IndentProps.max */;
+    const indent = clamp((node.attrs.indent || 0) + delta, minIndent, maxIndent);
+    if (indent === node.attrs.indent)
+        return tr;
+    const nodeAttrs = {
+        ...node.attrs,
+        indent,
+    };
+    return tr.setNodeMarkup(pos, node.type, nodeAttrs, node.marks);
+}
+function updateIndentLevel(tr, delta, types, editor) {
+    const { doc, selection } = tr;
+    if (!doc || !selection)
+        return tr;
+    if (!(selection instanceof TextSelection || selection instanceof AllSelection)) {
+        return tr;
+    }
+    const { from, to } = selection;
+    doc.nodesBetween(from, to, (node, pos) => {
+        const nodeType = node.type;
+        if (types.includes(nodeType.name)) {
+            tr = setNodeIndentMarkup(tr, pos, delta);
+            return false;
+        }
+        if (isList(node.type.name, editor.extensionManager.extensions)) {
+            return false;
+        }
+        return true;
+    });
+    return tr;
+}
+export function createIndentCommand({ delta, types }) {
+    return ({ state, dispatch, editor }) => {
+        const { selection } = state;
+        let { tr } = state;
+        tr = tr.setSelection(selection);
+        tr = updateIndentLevel(tr, delta, types, editor);
+        if (tr.docChanged) {
+            if (dispatch) {
+                dispatch(tr);
+            }
+            return true;
+        }
+        return false;
+    };
+}

package/es/components/organism/TextEditor/utils/index.d.ts

@@ -0,0 +1,8 @@
+export * from './selection';
+export * from './link';
+export * from './smartTag';
+export * from './style';
+export * from './font';
+export * from './htmlProcessing';
+export * from './menu';
+export * from './documentState';

package/es/components/organism/TextEditor/utils/index.js

@@ -0,0 +1,16 @@
+// Selection utilities
+export * from './selection';
+// Link utilities
+export * from './link';
+// Smart tag utilities
+export * from './smartTag';
+// Style utilities
+export * from './style';
+// Font utilities
+export * from './font';
+// HTML processing utilities
+export * from './htmlProcessing';
+// Menu utilities
+export * from './menu';
+// Document state utilities
+export * from './documentState';

package/es/components/organism/TextEditor/utils/link.d.ts

@@ -0,0 +1,116 @@
+import { EditorState } from '@tiptap/pm/state';
+import { EditorView } from '@tiptap/pm/view';
+import { LinkHandler, LinkMark, LinkMarkRange } from '../types';
+/**
+ * Kiểm tra xem cursor có đang nằm trong một đoạn text có mark là link hay không
+ * @param state EditorState của Tiptap/ProseMirror
+ * @returns true nếu cursor đang nằm trong link, false nếu không
+ */
+export declare const isCursorInLink: (state: EditorState) => boolean;
+/**
+ * Gets all link mark ranges within a specified range
+ * @param params Object containing state, from and to positions
+ * @returns Array of MarkRange objects for links
+ */
+export declare const getLinkMarkRanges: (params: {
+    state: EditorState;
+    from: number;
+    to: number;
+}) => LinkMarkRange[];
+/**
+ * Gets the range of a link mark at a specific position
+ * @param params Object containing state and optional position
+ * @returns Link mark range or undefined
+ */
+export declare const getLinkRange: (params: {
+    state: EditorState;
+    pos?: number;
+}) => void | import("@tiptap/core").Range;
+/**
+ * Gets the first link mark in a range
+ * @param params Object containing state, optional from and to positions
+ * @returns Link mark or undefined
+ */
+export declare const getLinkMark: (params: {
+    state: EditorState;
+    from?: number;
+    to?: number;
+}) => {
+    readonly type: import("prosemirror-model").MarkType;
+    addToSet: (set: readonly import("prosemirror-model").Mark[]) => readonly import("prosemirror-model").Mark[];
+    removeFromSet: (set: readonly import("prosemirror-model").Mark[]) => readonly import("prosemirror-model").Mark[];
+    isInSet: (set: readonly import("prosemirror-model").Mark[]) => boolean;
+    eq: (other: import("prosemirror-model").Mark) => boolean;
+    toJSON: () => any;
+    attrs: import("../types").LinkAttrs;
+} | undefined;
+/**
+ * Gets all link marks in a range
+ * @param params Object containing state, from and to positions
+ * @returns Array of link marks
+ */
+export declare const getLinkMarks: (params: {
+    state: EditorState;
+    from: number;
+    to: number;
+}) => LinkMark[];
+/**
+ * Gets all link attrs from a range
+ * @param params Object containing state, optional from and to positions
+ * @returns Array of link attrs
+ */
+export declare const getLinkAttrsFromRange: (params: {
+    state: EditorState;
+    from?: number;
+    to?: number;
+}) => import("../types").LinkAttrs[];
+/**
+ * Gets the active link attrs and inactive links from a range
+ * @param params Object containing state, optional from and to positions
+ * @returns Object with active link Attrs and inactiveLink Attrs or undefined
+ */
+export declare const getActiveLinkAttrsFromRange: (params: {
+    state: EditorState;
+    from?: number;
+    to?: number;
+}) => {
+    readonly activeAttrs: import("../types").LinkAttrs;
+    readonly inactiveLinks: import("../types").LinkAttrs[];
+} | undefined;
+/**
+ * Extends selection to include full link marks and adjacent links with same href
+ * @param state EditorState
+ * @param from Start position
+ * @param to End position
+ * @returns Object with extended from, to positions and link attrs
+ */
+export declare const extendSelectionToFullLinks: (state: EditorState, from: number, to: number) => {
+    from: number;
+    to: number;
+    linkAttrs?: undefined;
+} | {
+    from: number;
+    to: number;
+    linkAttrs: import("../types").LinkAttrs;
+};
+/**
+ * Gets all full link groups in the document (adjacent links with same href are grouped)
+ * @param state EditorState
+ * @returns Array of link groups with attrs and content
+ */
+export declare const getAllFullLinkGroups: (state: EditorState) => {
+    attrs: LinkMarkRange['mark']['attrs'];
+    content: string;
+}[];
+/**
+ * Handles link actions (create or edit)
+ * @param view EditorView instance
+ * @param linkHandler Link handler callbacks
+ */
+export declare function handleLinkAction(view: EditorView, linkHandler: LinkHandler | undefined): void;
+/**
+ * Checks if the link menu should be shown
+ * @param state EditorState
+ * @returns true if link menu should be shown
+ */
+export declare const isShowLinkToolbar: (state: EditorState) => boolean;