@uipath/apollo-react 4.39.5 → 4.41.0

package/dist/material/components/ap-rich-text-editor/plugins/MarkdownTransformers.cjs

@@ -0,0 +1,187 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    RTE_TRANSFORMERS: ()=>RTE_TRANSFORMERS
+});
+const markdown_namespaceObject = require("@lexical/markdown");
+const table_namespaceObject = require("@lexical/table");
+const external_lexical_namespaceObject = require("lexical");
+const UNDERLINE_EXPORTER_AND_TRANSFORMER = {
+    dependencies: [
+        external_lexical_namespaceObject.TextNode
+    ],
+    export: (node, _, exportFormat)=>{
+        if ((0, external_lexical_namespaceObject.$isTextNode)(node) && node.hasFormat('underline')) return '<u>' + exportFormat(node, node.getTextContent()) + '</u>';
+        return null;
+    },
+    importRegExp: /<u>(.*?)<\/u>/,
+    regExp: /<u>(.*?)<\/u>$/,
+    replace: (textNode, match)=>{
+        textNode.setFormat('underline');
+        textNode.setTextContent(match[1] ?? '');
+        return textNode;
+    },
+    trigger: '>',
+    type: 'text-match'
+};
+const UNDERLINE_IMPORTER = {
+    dependencies: [
+        external_lexical_namespaceObject.TextNode
+    ],
+    export: ()=>null,
+    regExp: /<u>(.*?)<\/u>/,
+    replace: (_, children, match)=>{
+        for (const child of children)if ((0, external_lexical_namespaceObject.$isTextNode)(child)) {
+            child.setFormat('underline');
+            child.setTextContent(match[1] ?? '');
+        }
+    },
+    type: 'element'
+};
+const TABLE_ROW_REG_EXP = /^(?:\|)(.+)(?:\|)\s?$/;
+const TABLE_ROW_DIVIDER_REG_EXP = /^\|(?:\s*:?-+:?\s*\|)+\s*$/;
+const TABLE = {
+    dependencies: [
+        table_namespaceObject.TableNode,
+        table_namespaceObject.TableRowNode,
+        table_namespaceObject.TableCellNode
+    ],
+    export: (node)=>{
+        if (!(0, table_namespaceObject.$isTableNode)(node)) return null;
+        const output = [];
+        for (const row of node.getChildren()){
+            const rowOutput = [];
+            if (!(0, table_namespaceObject.$isTableRowNode)(row)) continue;
+            let isHeaderRow = false;
+            for (const cell of row.getChildren())if ((0, table_namespaceObject.$isTableCellNode)(cell)) {
+                rowOutput.push((0, markdown_namespaceObject.$convertToMarkdownString)(RTE_TRANSFORMERS, cell).replace(/\n/g, '\\n'));
+                if (cell.__headerState === table_namespaceObject.TableCellHeaderStates.ROW) isHeaderRow = true;
+            }
+            output.push(`| ${rowOutput.join(' | ')} |`);
+            if (isHeaderRow) output.push(`| ${rowOutput.map(()=>'---').join(' | ')} |`);
+        }
+        return output.join('\n');
+    },
+    regExp: TABLE_ROW_REG_EXP,
+    replace: (parentNode, _1, match)=>{
+        const matchText = match[0] ?? '';
+        if (TABLE_ROW_DIVIDER_REG_EXP.test(matchText)) {
+            const table = parentNode.getPreviousSibling();
+            if (!table || !(0, table_namespaceObject.$isTableNode)(table)) return;
+            const rows = table.getChildren();
+            const lastRow = rows[rows.length - 1];
+            if (!lastRow || !(0, table_namespaceObject.$isTableRowNode)(lastRow)) return;
+            convertToHeaderCells(lastRow.getChildren());
+            parentNode.remove();
+            return;
+        }
+        const matchCells = mapToTableCells(matchText);
+        if (null == matchCells) return;
+        const rows = [
+            matchCells
+        ];
+        let sibling = parentNode.getPreviousSibling();
+        let maxCells = matchCells.length;
+        let isHeaderRow = false;
+        while(sibling){
+            if (!(0, external_lexical_namespaceObject.$isParagraphNode)(sibling)) break;
+            if (1 !== sibling.getChildrenSize()) break;
+            const firstChild = sibling.getFirstChild();
+            if (!(0, external_lexical_namespaceObject.$isTextNode)(firstChild)) break;
+            if (TABLE_ROW_DIVIDER_REG_EXP.test(firstChild.getTextContent())) isHeaderRow = true;
+            else {
+                const cells = mapToTableCells(firstChild.getTextContent());
+                if (null == cells) break;
+                if (isHeaderRow) {
+                    convertToHeaderCells(cells);
+                    isHeaderRow = false;
+                }
+                maxCells = Math.max(maxCells, cells.length);
+                rows.unshift(cells);
+            }
+            const previousSibling = sibling.getPreviousSibling();
+            sibling.remove();
+            sibling = previousSibling;
+        }
+        const table = (0, table_namespaceObject.$createTableNode)();
+        for (const cells of rows){
+            const tableRow = (0, table_namespaceObject.$createTableRowNode)();
+            table.append(tableRow);
+            tableRow.append(...cells);
+            const lenDiff = maxCells - cells.length;
+            const isInHeaderRow = cells[0]?.__headerState === table_namespaceObject.TableCellHeaderStates.ROW;
+            for(let i = 0; i < lenDiff; i++){
+                const newCell = $createTableCell('');
+                if (isInHeaderRow) newCell.toggleHeaderStyle(table_namespaceObject.TableCellHeaderStates.ROW);
+                tableRow.append(newCell);
+            }
+        }
+        const previousSibling = parentNode.getPreviousSibling();
+        if ((0, table_namespaceObject.$isTableNode)(previousSibling) && getTableColumnsSize(previousSibling) === maxCells) {
+            previousSibling.append(...table.getChildren());
+            parentNode.remove();
+            previousSibling.selectEnd();
+        } else {
+            parentNode.replace(table);
+            table.selectEnd();
+        }
+    },
+    type: 'element'
+};
+function getTableColumnsSize(table) {
+    const row = table.getFirstChild();
+    return (0, table_namespaceObject.$isTableRowNode)(row) ? row.getChildrenSize() : 0;
+}
+const $createTableCell = (textContent)=>{
+    textContent = textContent.replace(/\\r?\\n/g, '\n');
+    const cell = (0, table_namespaceObject.$createTableCellNode)(table_namespaceObject.TableCellHeaderStates.NO_STATUS);
+    (0, markdown_namespaceObject.$convertFromMarkdownString)(textContent, RTE_TRANSFORMERS, cell);
+    return cell;
+};
+const mapToTableCells = (textContent)=>{
+    const match = textContent.match(TABLE_ROW_REG_EXP);
+    if (!match?.[1]) return null;
+    return match[1].split('|').map((text)=>$createTableCell(text));
+};
+const convertToHeaderCells = (row)=>{
+    row.forEach((cell)=>{
+        if (!(0, table_namespaceObject.$isTableCellNode)(cell)) return;
+        cell.toggleHeaderStyle(table_namespaceObject.TableCellHeaderStates.ROW);
+    });
+};
+const RTE_TRANSFORMERS = [
+    ...markdown_namespaceObject.TRANSFORMERS,
+    UNDERLINE_EXPORTER_AND_TRANSFORMER,
+    UNDERLINE_IMPORTER,
+    TABLE
+];
+exports.RTE_TRANSFORMERS = __webpack_exports__.RTE_TRANSFORMERS;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "RTE_TRANSFORMERS"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/material/components/ap-rich-text-editor/plugins/MarkdownTransformers.d.ts

@@ -0,0 +1,2 @@
+export declare const RTE_TRANSFORMERS: import("@lexical/markdown").Transformer[];
+//# sourceMappingURL=MarkdownTransformers.d.ts.map

package/dist/material/components/ap-rich-text-editor/plugins/MarkdownTransformers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MarkdownTransformers.d.ts","sourceRoot":"","sources":["../../../../../src/material/components/ap-rich-text-editor/plugins/MarkdownTransformers.tsx"],"names":[],"mappings":"AAoPA,eAAO,MAAM,gBAAgB,2CAK5B,CAAC"}

package/dist/material/components/ap-rich-text-editor/plugins/MarkdownTransformers.js

@@ -0,0 +1,153 @@
+import { $convertFromMarkdownString, $convertToMarkdownString, TRANSFORMERS } from "@lexical/markdown";
+import { $createTableCellNode, $createTableNode, $createTableRowNode, $isTableCellNode, $isTableNode, $isTableRowNode, TableCellHeaderStates, TableCellNode, TableNode, TableRowNode } from "@lexical/table";
+import { $isParagraphNode, $isTextNode, TextNode } from "lexical";
+const UNDERLINE_EXPORTER_AND_TRANSFORMER = {
+    dependencies: [
+        TextNode
+    ],
+    export: (node, _, exportFormat)=>{
+        if ($isTextNode(node) && node.hasFormat('underline')) return '<u>' + exportFormat(node, node.getTextContent()) + '</u>';
+        return null;
+    },
+    importRegExp: /<u>(.*?)<\/u>/,
+    regExp: /<u>(.*?)<\/u>$/,
+    replace: (textNode, match)=>{
+        textNode.setFormat('underline');
+        textNode.setTextContent(match[1] ?? '');
+        return textNode;
+    },
+    trigger: '>',
+    type: 'text-match'
+};
+const UNDERLINE_IMPORTER = {
+    dependencies: [
+        TextNode
+    ],
+    export: ()=>null,
+    regExp: /<u>(.*?)<\/u>/,
+    replace: (_, children, match)=>{
+        for (const child of children)if ($isTextNode(child)) {
+            child.setFormat('underline');
+            child.setTextContent(match[1] ?? '');
+        }
+    },
+    type: 'element'
+};
+const TABLE_ROW_REG_EXP = /^(?:\|)(.+)(?:\|)\s?$/;
+const TABLE_ROW_DIVIDER_REG_EXP = /^\|(?:\s*:?-+:?\s*\|)+\s*$/;
+const TABLE = {
+    dependencies: [
+        TableNode,
+        TableRowNode,
+        TableCellNode
+    ],
+    export: (node)=>{
+        if (!$isTableNode(node)) return null;
+        const output = [];
+        for (const row of node.getChildren()){
+            const rowOutput = [];
+            if (!$isTableRowNode(row)) continue;
+            let isHeaderRow = false;
+            for (const cell of row.getChildren())if ($isTableCellNode(cell)) {
+                rowOutput.push($convertToMarkdownString(RTE_TRANSFORMERS, cell).replace(/\n/g, '\\n'));
+                if (cell.__headerState === TableCellHeaderStates.ROW) isHeaderRow = true;
+            }
+            output.push(`| ${rowOutput.join(' | ')} |`);
+            if (isHeaderRow) output.push(`| ${rowOutput.map(()=>'---').join(' | ')} |`);
+        }
+        return output.join('\n');
+    },
+    regExp: TABLE_ROW_REG_EXP,
+    replace: (parentNode, _1, match)=>{
+        const matchText = match[0] ?? '';
+        if (TABLE_ROW_DIVIDER_REG_EXP.test(matchText)) {
+            const table = parentNode.getPreviousSibling();
+            if (!table || !$isTableNode(table)) return;
+            const rows = table.getChildren();
+            const lastRow = rows[rows.length - 1];
+            if (!lastRow || !$isTableRowNode(lastRow)) return;
+            convertToHeaderCells(lastRow.getChildren());
+            parentNode.remove();
+            return;
+        }
+        const matchCells = mapToTableCells(matchText);
+        if (null == matchCells) return;
+        const rows = [
+            matchCells
+        ];
+        let sibling = parentNode.getPreviousSibling();
+        let maxCells = matchCells.length;
+        let isHeaderRow = false;
+        while(sibling){
+            if (!$isParagraphNode(sibling)) break;
+            if (1 !== sibling.getChildrenSize()) break;
+            const firstChild = sibling.getFirstChild();
+            if (!$isTextNode(firstChild)) break;
+            if (TABLE_ROW_DIVIDER_REG_EXP.test(firstChild.getTextContent())) isHeaderRow = true;
+            else {
+                const cells = mapToTableCells(firstChild.getTextContent());
+                if (null == cells) break;
+                if (isHeaderRow) {
+                    convertToHeaderCells(cells);
+                    isHeaderRow = false;
+                }
+                maxCells = Math.max(maxCells, cells.length);
+                rows.unshift(cells);
+            }
+            const previousSibling = sibling.getPreviousSibling();
+            sibling.remove();
+            sibling = previousSibling;
+        }
+        const table = $createTableNode();
+        for (const cells of rows){
+            const tableRow = $createTableRowNode();
+            table.append(tableRow);
+            tableRow.append(...cells);
+            const lenDiff = maxCells - cells.length;
+            const isInHeaderRow = cells[0]?.__headerState === TableCellHeaderStates.ROW;
+            for(let i = 0; i < lenDiff; i++){
+                const newCell = $createTableCell('');
+                if (isInHeaderRow) newCell.toggleHeaderStyle(TableCellHeaderStates.ROW);
+                tableRow.append(newCell);
+            }
+        }
+        const previousSibling = parentNode.getPreviousSibling();
+        if ($isTableNode(previousSibling) && getTableColumnsSize(previousSibling) === maxCells) {
+            previousSibling.append(...table.getChildren());
+            parentNode.remove();
+            previousSibling.selectEnd();
+        } else {
+            parentNode.replace(table);
+            table.selectEnd();
+        }
+    },
+    type: 'element'
+};
+function getTableColumnsSize(table) {
+    const row = table.getFirstChild();
+    return $isTableRowNode(row) ? row.getChildrenSize() : 0;
+}
+const $createTableCell = (textContent)=>{
+    textContent = textContent.replace(/\\r?\\n/g, '\n');
+    const cell = $createTableCellNode(TableCellHeaderStates.NO_STATUS);
+    $convertFromMarkdownString(textContent, RTE_TRANSFORMERS, cell);
+    return cell;
+};
+const mapToTableCells = (textContent)=>{
+    const match = textContent.match(TABLE_ROW_REG_EXP);
+    if (!match?.[1]) return null;
+    return match[1].split('|').map((text)=>$createTableCell(text));
+};
+const convertToHeaderCells = (row)=>{
+    row.forEach((cell)=>{
+        if (!$isTableCellNode(cell)) return;
+        cell.toggleHeaderStyle(TableCellHeaderStates.ROW);
+    });
+};
+const RTE_TRANSFORMERS = [
+    ...TRANSFORMERS,
+    UNDERLINE_EXPORTER_AND_TRANSFORMER,
+    UNDERLINE_IMPORTER,
+    TABLE
+];
+export { RTE_TRANSFORMERS };

package/dist/material/components/ap-rich-text-editor/plugins/ToolbarPlugin.cjs

@@ -0,0 +1,306 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    default: ()=>ToolbarPlugin
+});
+const jsx_runtime_namespaceObject = require("react/jsx-runtime");
+const link_namespaceObject = require("@lexical/link");
+const list_namespaceObject = require("@lexical/list");
+const LexicalComposerContext_namespaceObject = require("@lexical/react/LexicalComposerContext");
+const rich_text_namespaceObject = require("@lexical/rich-text");
+const selection_namespaceObject = require("@lexical/selection");
+const utils_namespaceObject = require("@lexical/utils");
+const icons_material_namespaceObject = require("@mui/icons-material");
+const material_namespaceObject = require("@mui/material");
+const external_lexical_namespaceObject = require("lexical");
+const external_react_namespaceObject = require("react");
+const useSafeLingui_cjs_namespaceObject = require("../../../../i18n/useSafeLingui.cjs");
+const LowPriority = 1;
+function Divider() {
+    return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("div", {
+        className: "divider"
+    });
+}
+function getSelectedNode(selection) {
+    const anchor = selection.anchor;
+    const focus = selection.focus;
+    const anchorNode = selection.anchor.getNode();
+    const focusNode = selection.focus.getNode();
+    if (anchorNode === focusNode) return anchorNode;
+    const isBackward = selection.isBackward();
+    if (isBackward) return (0, selection_namespaceObject.$isAtNodeEnd)(focus) ? anchorNode : focusNode;
+    return (0, selection_namespaceObject.$isAtNodeEnd)(anchor) ? focusNode : anchorNode;
+}
+function ToolbarPlugin({ disabled = false }) {
+    const [editor] = (0, LexicalComposerContext_namespaceObject.useLexicalComposerContext)();
+    const toolbarRef = (0, external_react_namespaceObject.useRef)(null);
+    const { _ } = (0, useSafeLingui_cjs_namespaceObject.useSafeLingui)();
+    const [isBold, setIsBold] = (0, external_react_namespaceObject.useState)(false);
+    const [isItalic, setIsItalic] = (0, external_react_namespaceObject.useState)(false);
+    const [isUnderline, setIsUnderline] = (0, external_react_namespaceObject.useState)(false);
+    const [isStrikethrough, setIsStrikethrough] = (0, external_react_namespaceObject.useState)(false);
+    const [blockType, setBlockType] = (0, external_react_namespaceObject.useState)('paragraph');
+    const [isLink, setIsLink] = (0, external_react_namespaceObject.useState)(false);
+    const [isCode, setIsCode] = (0, external_react_namespaceObject.useState)(false);
+    const $updateToolbar = (0, external_react_namespaceObject.useCallback)(()=>{
+        const selection = (0, external_lexical_namespaceObject.$getSelection)();
+        if ((0, external_lexical_namespaceObject.$isRangeSelection)(selection)) {
+            const anchorNode = selection.anchor.getNode();
+            const element = 'root' === anchorNode.getKey() ? anchorNode : anchorNode.getTopLevelElementOrThrow();
+            const elementKey = element.getKey();
+            const elementDOM = editor.getElementByKey(elementKey);
+            if (null !== elementDOM) if ((0, list_namespaceObject.$isListNode)(element)) {
+                const parentList = (0, utils_namespaceObject.$getNearestNodeOfType)(anchorNode, list_namespaceObject.ListNode);
+                const type = parentList ? parentList.getTag() : element.getTag();
+                setBlockType(type);
+            } else {
+                const type = (0, rich_text_namespaceObject.$isHeadingNode)(element) ? element.getTag() : element.getType();
+                setBlockType(type);
+            }
+            setIsBold(selection.hasFormat('bold'));
+            setIsItalic(selection.hasFormat('italic'));
+            setIsUnderline(selection.hasFormat('underline'));
+            setIsStrikethrough(selection.hasFormat('strikethrough'));
+            setIsCode(selection.hasFormat('code'));
+            const node = getSelectedNode(selection);
+            const parent = node.getParent();
+            (0, link_namespaceObject.$isLinkNode)(parent) || (0, link_namespaceObject.$isLinkNode)(node) ? setIsLink(true) : setIsLink(false);
+        }
+    }, [
+        editor
+    ]);
+    (0, external_react_namespaceObject.useEffect)(()=>(0, utils_namespaceObject.mergeRegister)(editor.registerUpdateListener(({ editorState })=>{
+            editorState.read(()=>{
+                $updateToolbar();
+            });
+        }), editor.registerCommand(external_lexical_namespaceObject.SELECTION_CHANGE_COMMAND, ()=>{
+            $updateToolbar();
+            return false;
+        }, LowPriority)), [
+        editor,
+        $updateToolbar
+    ]);
+    return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsxs)("div", {
+        className: `toolbar${disabled ? ' disabled' : ''}`,
+        ref: toolbarRef,
+        role: "toolbar",
+        "aria-orientation": "horizontal",
+        "aria-disabled": disabled,
+        children: [
+            /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(material_namespaceObject.Tooltip, {
+                title: _({
+                    id: 'rich-text-editor.bold'
+                }),
+                children: /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("button", {
+                    type: "button",
+                    onClick: ()=>{
+                        editor.dispatchCommand(external_lexical_namespaceObject.FORMAT_TEXT_COMMAND, 'bold');
+                    },
+                    disabled: disabled,
+                    className: 'toolbar-item spaced ' + (isBold ? 'active' : ''),
+                    "aria-pressed": isBold,
+                    "aria-label": _({
+                        id: 'rich-text-editor.format-bold'
+                    }),
+                    children: /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(icons_material_namespaceObject.FormatBold, {
+                        sx: {
+                            fontSize: '24px'
+                        }
+                    })
+                })
+            }),
+            /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(material_namespaceObject.Tooltip, {
+                title: _({
+                    id: 'rich-text-editor.italic'
+                }),
+                children: /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("button", {
+                    type: "button",
+                    onClick: ()=>{
+                        editor.dispatchCommand(external_lexical_namespaceObject.FORMAT_TEXT_COMMAND, 'italic');
+                    },
+                    className: 'toolbar-item spaced ' + (isItalic ? 'active' : ''),
+                    "aria-pressed": isItalic,
+                    disabled: disabled,
+                    "aria-label": _({
+                        id: 'rich-text-editor.format-italic'
+                    }),
+                    children: /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(icons_material_namespaceObject.FormatItalic, {
+                        sx: {
+                            fontSize: '24px'
+                        }
+                    })
+                })
+            }),
+            /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(material_namespaceObject.Tooltip, {
+                title: _({
+                    id: 'rich-text-editor.underline'
+                }),
+                children: /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("button", {
+                    type: "button",
+                    onClick: ()=>{
+                        editor.dispatchCommand(external_lexical_namespaceObject.FORMAT_TEXT_COMMAND, 'underline');
+                    },
+                    className: 'toolbar-item spaced ' + (isUnderline ? 'active' : ''),
+                    "aria-pressed": isUnderline,
+                    disabled: disabled,
+                    "aria-label": _({
+                        id: 'rich-text-editor.format-underline'
+                    }),
+                    children: /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(icons_material_namespaceObject.FormatUnderlined, {
+                        sx: {
+                            fontSize: '24px'
+                        }
+                    })
+                })
+            }),
+            /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(material_namespaceObject.Tooltip, {
+                title: _({
+                    id: 'rich-text-editor.strikethrough'
+                }),
+                children: /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("button", {
+                    type: "button",
+                    onClick: ()=>{
+                        editor.dispatchCommand(external_lexical_namespaceObject.FORMAT_TEXT_COMMAND, 'strikethrough');
+                    },
+                    className: 'toolbar-item spaced ' + (isStrikethrough ? 'active' : ''),
+                    "aria-pressed": isStrikethrough,
+                    disabled: disabled,
+                    "aria-label": _({
+                        id: 'rich-text-editor.format-strikethrough'
+                    }),
+                    children: /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(icons_material_namespaceObject.FormatStrikethrough, {
+                        sx: {
+                            fontSize: '24px'
+                        }
+                    })
+                })
+            }),
+            /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(Divider, {}),
+            /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(material_namespaceObject.Tooltip, {
+                title: _({
+                    id: 'rich-text-editor.unordered-list'
+                }),
+                children: /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("button", {
+                    type: "button",
+                    onClick: ()=>{
+                        if ('ul' !== blockType) editor.dispatchCommand(list_namespaceObject.INSERT_UNORDERED_LIST_COMMAND, void 0);
+                        else editor.dispatchCommand(list_namespaceObject.REMOVE_LIST_COMMAND, void 0);
+                    },
+                    className: 'toolbar-item spaced ' + ('ul' === blockType ? 'active' : ''),
+                    disabled: disabled,
+                    "aria-pressed": 'ul' === blockType,
+                    "aria-label": _({
+                        id: 'rich-text-editor.format-unordered-list'
+                    }),
+                    children: /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(icons_material_namespaceObject.FormatListBulleted, {
+                        sx: {
+                            fontSize: '24px'
+                        }
+                    })
+                })
+            }),
+            /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(material_namespaceObject.Tooltip, {
+                title: _({
+                    id: 'rich-text-editor.ordered-list'
+                }),
+                children: /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("button", {
+                    type: "button",
+                    onClick: ()=>{
+                        if ('ol' !== blockType) editor.dispatchCommand(list_namespaceObject.INSERT_ORDERED_LIST_COMMAND, void 0);
+                        else editor.dispatchCommand(list_namespaceObject.REMOVE_LIST_COMMAND, void 0);
+                    },
+                    className: 'toolbar-item spaced ' + ('ol' === blockType ? 'active' : ''),
+                    disabled: disabled,
+                    "aria-pressed": 'ol' === blockType,
+                    "aria-label": _({
+                        id: 'rich-text-editor.format-ordered-list'
+                    }),
+                    children: /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(icons_material_namespaceObject.FormatListNumbered, {
+                        sx: {
+                            fontSize: '24px'
+                        }
+                    })
+                })
+            }),
+            /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(Divider, {}),
+            /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(material_namespaceObject.Tooltip, {
+                title: _({
+                    id: 'rich-text-editor.link'
+                }),
+                children: /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("button", {
+                    type: "button",
+                    onClick: ()=>{
+                        if (isLink) editor.dispatchCommand(link_namespaceObject.TOGGLE_LINK_COMMAND, null);
+                        else editor.update(()=>{
+                            const selection = (0, external_lexical_namespaceObject.$getSelection)();
+                            if ((0, external_lexical_namespaceObject.$isRangeSelection)(selection)) selection.insertText(`[${selection.getTextContent() || 'text'}](link)`);
+                        });
+                    },
+                    className: 'toolbar-item spaced ' + (isLink ? 'active' : ''),
+                    disabled: disabled,
+                    "aria-pressed": isLink,
+                    "aria-label": _({
+                        id: 'rich-text-editor.insert-link'
+                    }),
+                    children: /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(icons_material_namespaceObject.Link, {
+                        sx: {
+                            fontSize: '24px'
+                        }
+                    })
+                })
+            }),
+            /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(material_namespaceObject.Tooltip, {
+                title: _({
+                    id: 'rich-text-editor.code'
+                }),
+                children: /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("button", {
+                    type: "button",
+                    onClick: ()=>{
+                        editor.dispatchCommand(external_lexical_namespaceObject.FORMAT_TEXT_COMMAND, 'code');
+                    },
+                    className: 'toolbar-item spaced ' + (isCode ? 'active' : ''),
+                    "aria-pressed": isCode,
+                    disabled: disabled,
+                    "aria-label": _({
+                        id: 'rich-text-editor.format-code'
+                    }),
+                    children: /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(icons_material_namespaceObject.Code, {
+                        sx: {
+                            fontSize: '24px'
+                        }
+                    })
+                })
+            })
+        ]
+    });
+}
+exports["default"] = __webpack_exports__["default"];
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "default"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/material/components/ap-rich-text-editor/plugins/ToolbarPlugin.d.ts

@@ -0,0 +1,4 @@
+export default function ToolbarPlugin({ disabled }: {
+    disabled?: boolean;
+}): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=ToolbarPlugin.d.ts.map

package/dist/material/components/ap-rich-text-editor/plugins/ToolbarPlugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ToolbarPlugin.d.ts","sourceRoot":"","sources":["../../../../../src/material/components/ap-rich-text-editor/plugins/ToolbarPlugin.tsx"],"names":[],"mappings":"AAwDA,MAAM,CAAC,OAAO,UAAU,aAAa,CAAC,EAAE,QAAgB,EAAE,EAAE;IAAE,QAAQ,CAAC,EAAE,OAAO,CAAA;CAAE,2CA0NjF"}