@gravity-ui/markdown-editor 13.17.1 → 13.18.0

package/build/cjs/table-utils/commands/removeColumn.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.removeColumn = void 0;
-const __1 = require("..");
+const table_desc_1 = require("../table-desc");
 const utils_1 = require("../utils");
 const removeColumn = (state, dispatch, _, attrs = {}) => {
     const { tablePos, columnNumber } = attrs;
@@ -12,30 +12,28 @@ const removeColumn = (state, dispatch, _, attrs = {}) => {
     if (tablePos < 0 || columnNumber < 0)
         return false;
     const tableNode = state.doc.nodeAt(tablePos);
-    if (!tableNode || tableNode.nodeSize <= 2 || !(0, __1.isTableNode)(tableNode))
+    if (!tableNode || tableNode.nodeSize <= 2 || !(0, utils_1.isTableNode)(tableNode))
         return false;
-    const tableBodyNode = tableNode.firstChild;
-    if (!tableBodyNode || tableBodyNode.nodeSize <= 2 || !(0, utils_1.isTableBodyNode)(tableBodyNode))
+    const tableDesc = table_desc_1.TableDesc.create(tableNode);
+    if (!tableDesc)
         return false;
-    // there is one column left
-    if (tableBodyNode.firstChild && tableBodyNode.firstChild.childCount < 2)
+    if (!tableDesc ||
+        // there is one column left
+        tableDesc.cols < 2 ||
+        tableDesc.cols <= columnNumber ||
+        !tableDesc.isSafeColumn(columnNumber))
         return false;
     if (dispatch) {
         const { tr } = state;
-        tableBodyNode.forEach((rowNode, rowOffset) => {
-            if (!(0, utils_1.isTableRowNode)(rowNode))
-                return;
-            rowNode.forEach((cellNode, cellOffset, cellIndex) => {
-                if (!(0, utils_1.isTableCellNode)(cellNode))
-                    return;
-                if (cellIndex === columnNumber) {
-                    // table -> tbody -> tr -> td
-                    const from = tablePos + 2 + rowOffset + 1 + cellOffset;
-                    const to = from + cellNode.nodeSize;
-                    tr.delete(tr.mapping.map(from), tr.mapping.map(to));
-                }
-            });
-        });
+        const pos = tableDesc.getRelativePosForColumn(columnNumber);
+        for (const item of pos) {
+            if (item.type === 'real') {
+                let { from, to } = item;
+                from += tablePos;
+                to += tablePos;
+                tr.delete(tr.mapping.map(from), tr.mapping.map(to));
+            }
+        }
         dispatch(tr);
     }
     return true;

package/build/cjs/table-utils/commands/removeRow.js

@@ -5,7 +5,7 @@ const prosemirror_model_1 = require("prosemirror-model");
 const prosemirror_utils_1 = require("prosemirror-utils");
 const __1 = require("..");
 const core_1 = require("../../core");
-const utils_1 = require("../utils");
+const table_desc_1 = require("../table-desc");
 const removeRow = (state, dispatch, _, attrs = {}) => {
     var _a;
     const { tablePos, rowNumber } = attrs;
@@ -14,17 +14,20 @@ const removeRow = (state, dispatch, _, attrs = {}) => {
     const tableNode = (_a = (0, prosemirror_utils_1.findParentNodeClosestToPos)(state.doc.resolve(tablePos + 1), __1.isTableNode)) === null || _a === void 0 ? void 0 : _a.node;
     if (!tableNode)
         return false;
-    const parentRows = (0, prosemirror_utils_1.findChildren)(tableNode, __1.isTableRowNode);
-    const parentBody = (0, __1.findChildTableBody)(tableNode)[0];
-    const parentRow = parentRows[rowNumber];
-    if (!parentRows.length || !parentBody) {
+    const tableDesc = table_desc_1.TableDesc.create(tableNode);
+    if (!tableDesc || rowNumber >= tableDesc.rows)
         return false;
-    }
-    if ((0, utils_1.findChildTableRows)(parentBody.node).length < 2) {
-        // there is one row left
+    if (!tableDesc.isSafeRow(rowNumber))
         return false;
+    if (dispatch) {
+        let { from, to } = tableDesc.getRelativePosForRow(rowNumber);
+        from += tablePos;
+        to += tablePos;
+        dispatch((0, core_1.trackTransactionMetrics)(state.tr.replaceWith(from, to, prosemirror_model_1.Fragment.empty), 'removeRow', {
+            rows: tableDesc.rows,
+            cols: tableDesc.cols,
+        }));
     }
-    dispatch === null || dispatch === void 0 ? void 0 : dispatch((0, core_1.trackTransactionMetrics)(state.tr.replaceWith(tablePos + parentRow.pos, tablePos + parentRow.pos + parentRow.node.nodeSize + 1, prosemirror_model_1.Fragment.empty), 'removeRow', { rows: parentRows.length, cols: parentRow.node.childCount }));
     return true;
 };
 exports.removeRow = removeRow;

package/build/cjs/table-utils/table-desc.d.ts

@@ -0,0 +1,53 @@
+import type { Node } from 'prosemirror-model';
+declare type TableCellRealDesc = {
+    type: 'real';
+    offset: number;
+    node: Node;
+    colspan?: number;
+    rowspan?: number;
+};
+declare type TableCellVirtualDesc = {
+    type: 'virtual';
+    /** Index of real cell, that prodeced this virtual cell */
+    colspan?: [number, number];
+    /** Index of real cell, that prodeced this virtual cell */
+    rowspan?: [number, number];
+};
+declare type Pos = {
+    from: number;
+    to: number;
+};
+export declare type CellPos = ({
+    type: 'real';
+} & Pos) | {
+    type: 'virtual';
+    closestPos: number;
+};
+declare type TableCellDesc = TableCellRealDesc | TableCellVirtualDesc;
+declare type TableRowDesc = {
+    node: Node;
+    cells: TableCellDesc[];
+    offset: number;
+    colspan?: boolean;
+    rowspan?: boolean;
+};
+export declare class TableDesc {
+    readonly rows: number;
+    readonly cols: number;
+    readonly rowsDesc: readonly TableRowDesc[];
+    readonly baseOffset: number;
+    private static __cache;
+    static create(table: Node): TableDesc | null;
+    private constructor();
+    rowHasVirtualCells(rowIndex: number): boolean;
+    columnHasVirtualCells(columnIndex: number): boolean;
+    isSafeColumn(columnIndex: number): boolean;
+    isSafeRow(rowIndex: number): boolean;
+    getOffsetForRow(rowIndex: number): number;
+    getRelativePosForRow(rowIndex: number): Pos;
+    getRelativePosForCell(rowIndex: number, columnIndex: number): CellPos;
+    getRelativePosForColumn(columnIndex: number): CellPos[];
+    getCellNodeType(): import("prosemirror-model").NodeType;
+    getRowNodeType(): import("prosemirror-model").NodeType;
+}
+export {};

package/build/cjs/table-utils/table-desc.js

@@ -0,0 +1,149 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TableDesc = void 0;
+const tslib_1 = require("tslib");
+const is_number_1 = tslib_1.__importDefault(require("is-number"));
+const utils_1 = require("./utils");
+class TableDesc {
+    constructor(
+    /* eslint-disable @typescript-eslint/parameter-properties */
+    rows, cols, rowsDesc, baseOffset) {
+        this.rows = rows;
+        this.cols = cols;
+        this.rowsDesc = rowsDesc;
+        this.baseOffset = baseOffset;
+    }
+    static create(table) {
+        if (this.__cache.has(table))
+            return this.__cache.get(table);
+        if (!(0, utils_1.isTableNode)(table))
+            return null;
+        const tbody = table.lastChild;
+        if (!tbody || !(0, utils_1.isTableBodyNode)(tbody))
+            return null;
+        // table –> tbody -> ...
+        const baseOffset = 2;
+        const rows = [];
+        tbody.forEach((trow, offset) => {
+            rows.push({ node: trow, offset, cells: [] });
+        });
+        tbody.forEach((trow, _1, trowIndex) => {
+            trow.forEach((tcell, offset, tcellRealIndex) => {
+                var _a;
+                const rowDesc = rows[trowIndex];
+                let tcellIndex = tcellRealIndex;
+                while (rowDesc.cells[tcellIndex]) {
+                    tcellIndex++;
+                }
+                const cellDesc = (rowDesc.cells[tcellIndex] = {
+                    type: 'real',
+                    node: tcell,
+                    offset,
+                });
+                const map = [trowIndex, tcellIndex];
+                if ((0, is_number_1.default)(tcell.attrs['colspan'])) {
+                    rowDesc.colspan = true;
+                    const colspan = (cellDesc.colspan = parseInt(tcell.attrs['colspan'], 10));
+                    for (let i = 1; i < colspan; i++) {
+                        rowDesc.cells[tcellIndex + i] = {
+                            type: 'virtual',
+                            colspan: map,
+                        };
+                    }
+                }
+                if ((0, is_number_1.default)(tcell.attrs['rowspan'])) {
+                    rowDesc.rowspan = true;
+                    const rowspan = (cellDesc.rowspan = parseInt(tcell.attrs['rowspan'], 10));
+                    for (let i = 1; i < rowspan; i++) {
+                        const colspan = (_a = cellDesc.colspan) !== null && _a !== void 0 ? _a : 1;
+                        for (let j = 0; j < colspan; j++)
+                            rows[trowIndex + i].cells[tcellIndex + j] = {
+                                type: 'virtual',
+                                rowspan: map,
+                            };
+                    }
+                }
+            });
+        });
+        const desc = new this(rows.length, rows[0].cells.length, rows, baseOffset);
+        this.__cache.set(table, desc);
+        return desc;
+    }
+    rowHasVirtualCells(rowIndex) {
+        var _a;
+        return (_a = this.rowsDesc[rowIndex]) === null || _a === void 0 ? void 0 : _a.cells.some((cell) => cell.type === 'virtual');
+    }
+    columnHasVirtualCells(columnIndex) {
+        return this.rowsDesc.some((row) => { var _a; return ((_a = row.cells[columnIndex]) === null || _a === void 0 ? void 0 : _a.type) === 'virtual'; });
+    }
+    isSafeColumn(columnIndex) {
+        return this.rowsDesc.every((row) => {
+            var _a;
+            const cell = row.cells[columnIndex];
+            if (cell.type === 'real' && (!cell.colspan || cell.colspan === 1))
+                return true;
+            if (cell.type === 'virtual' && ((_a = cell.rowspan) === null || _a === void 0 ? void 0 : _a[1]) === columnIndex)
+                return true;
+            return false;
+        });
+    }
+    isSafeRow(rowIndex) {
+        var _a;
+        return (_a = this.rowsDesc[rowIndex]) === null || _a === void 0 ? void 0 : _a.cells.every((cell) => {
+            var _a;
+            if (cell.type === 'real' && (!cell.rowspan || cell.rowspan === 1))
+                return true;
+            if (cell.type === 'virtual' && ((_a = cell.colspan) === null || _a === void 0 ? void 0 : _a[0]) === rowIndex)
+                return true;
+            return false;
+        });
+    }
+    getOffsetForRow(rowIndex) {
+        var _a;
+        return this.baseOffset + ((_a = this.rowsDesc[rowIndex]) === null || _a === void 0 ? void 0 : _a.offset);
+    }
+    getRelativePosForRow(rowIndex) {
+        const from = this.getOffsetForRow(rowIndex);
+        const to = from + this.rowsDesc[rowIndex].node.nodeSize;
+        return { from, to };
+    }
+    getRelativePosForCell(rowIndex, columnIndex) {
+        var _a;
+        const cell = (_a = this.rowsDesc[rowIndex]) === null || _a === void 0 ? void 0 : _a.cells[columnIndex];
+        const rowOffset = this.getOffsetForRow(rowIndex);
+        if ((cell === null || cell === void 0 ? void 0 : cell.type) === 'real') {
+            // 1 – open boundary for row node
+            const from = rowOffset + 1 + cell.offset;
+            const to = from + cell.node.nodeSize;
+            return { type: 'real', from, to };
+        }
+        if ((cell === null || cell === void 0 ? void 0 : cell.type) === 'virtual') {
+            let index = columnIndex;
+            while (--index >= 0) {
+                const cell = this.rowsDesc[rowIndex].cells[index];
+                if (cell.type === 'real') {
+                    const closest = rowOffset + 1 + cell.offset + cell.node.nodeSize;
+                    return { type: 'virtual', closestPos: closest };
+                }
+            }
+            return { type: 'virtual', closestPos: rowOffset + 1 };
+        }
+        throw new Error(`Impossible to calculate offset for cell with position [${rowIndex},${columnIndex}]`);
+    }
+    getRelativePosForColumn(columnIndex) {
+        const ranges = [];
+        for (let i = 0; i < this.rows; i++) {
+            ranges.push(this.getRelativePosForCell(i, columnIndex));
+        }
+        return ranges;
+    }
+    getCellNodeType() {
+        const isRealCell = (cell) => cell.type === 'real';
+        return this.rowsDesc[0].cells.find(isRealCell).node.type;
+    }
+    getRowNodeType() {
+        return this.rowsDesc[0].node.type;
+    }
+}
+exports.TableDesc = TableDesc;
+TableDesc.__cache = new WeakMap();

package/build/cjs/table-utils/utils.d.ts

@@ -25,7 +25,7 @@ export declare const findChildTableBody: (node: PmNode) => {
     node: PmNode;
     pos: number;
 }[];
-export declare const getTableDimensions: (node: PmNode | Node) => {
+export declare const getTableDimensions: (node: PmNode) => {
     rows: number;
     cols: number;
 };

package/build/cjs/table-utils/utils.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.atEndOfCell = exports.getTableDimensions = exports.findChildTableBody = exports.findChildTableCells = exports.findChildTableRows = exports.findParentTableCellFromPos = exports.findParentTableRowFromPos = exports.findParentTableBodyFromPos = exports.findParentTableFromPos = exports.findParentTableCell = exports.findParentTableRow = exports.findParentTableBody = exports.findParentTable = exports.isTableCellNode = exports.isTableRowNode = exports.isTableBodyNode = exports.isTableNode = void 0;
-const prosemirror_model_1 = require("prosemirror-model");
+const tslib_1 = require("tslib");
+const is_number_1 = tslib_1.__importDefault(require("is-number"));
 const prosemirror_utils_1 = require("prosemirror-utils");
 const selection_1 = require("../utils/selection");
 const const_1 = require("./const");
@@ -32,17 +33,23 @@ exports.findChildTableCells = findChildTableCells;
 const findChildTableBody = (node) => (0, prosemirror_utils_1.findChildren)(node, exports.isTableBodyNode);
 exports.findChildTableBody = findChildTableBody;
 const getTableDimensions = (node) => {
-    var _a, _b, _c, _d, _e, _f;
-    let rows, cols;
-    if (node instanceof prosemirror_model_1.Node) {
-        rows = (_a = node.firstChild) === null || _a === void 0 ? void 0 : _a.childCount;
-        cols = (_c = (_b = node.firstChild) === null || _b === void 0 ? void 0 : _b.firstChild) === null || _c === void 0 ? void 0 : _c.childCount;
-    }
-    else {
-        rows = (_d = node.firstChild) === null || _d === void 0 ? void 0 : _d.childNodes.length;
-        cols = (_f = (_e = node.firstChild) === null || _e === void 0 ? void 0 : _e.firstChild) === null || _f === void 0 ? void 0 : _f.childNodes.length;
-    }
-    return { rows: rows || 1, cols: cols || 1 };
+    let rows = 0, cols = 0;
+    const tbody = node.firstChild;
+    tbody === null || tbody === void 0 ? void 0 : tbody.forEach((trow, _1, trowIndex) => {
+        rows++;
+        if (trowIndex === 0) {
+            trow.forEach((tcell, _2) => {
+                const cellAttrs = tcell.attrs;
+                if ((0, is_number_1.default)(cellAttrs['colspan'])) {
+                    cols += parseInt(cellAttrs['colspan'], 10);
+                }
+                else {
+                    cols++;
+                }
+            });
+        }
+    });
+    return { rows, cols };
 };
 exports.getTableDimensions = getTableDimensions;
 function atEndOfCell(view, dir) {

package/build/cjs/version.js

@@ -2,4 +2,4 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.VERSION = void 0;
 /** During build process, the current version will be injected here */
-exports.VERSION = typeof '13.17.1' !== 'undefined' ? '13.17.1' : 'unknown';
+exports.VERSION = typeof '13.18.0' !== 'undefined' ? '13.18.0' : 'unknown';

package/build/esm/bundle/config/action-names.d.ts

@@ -1,3 +1,3 @@
-declare const namesObj: Record<"bold" | "link" | "italic" | "strike" | "underline" | "mark" | "quote" | "mono" | "paragraph" | "anchor" | "table" | "image" | "code_inline" | "code_block" | "file" | "checkbox" | "bulletList" | "orderedList" | "emoji" | "tabs" | "yfm_cut" | "heading1" | "heading2" | "heading3" | "heading4" | "heading5" | "heading6" | "yfm_note" | "undo" | "redo" | "math_inline" | "math_block" | "mermaid" | "liftListItem" | "sinkListItem" | "yfm_block" | "yfm_html_block" | "yfm_layout" | "horizontalrule", string>;
+declare const namesObj: Record<"bold" | "link" | "italic" | "strike" | "underline" | "mark" | "quote" | "mono" | "paragraph" | "anchor" | "table" | "image" | "code_inline" | "code_block" | "file" | "checkbox" | "bulletList" | "orderedList" | "emoji" | "tabs" | "yfm_cut" | "heading1" | "heading2" | "heading3" | "heading4" | "heading5" | "heading6" | "yfm_note" | "gpt" | "undo" | "redo" | "math_inline" | "math_block" | "mermaid" | "liftListItem" | "sinkListItem" | "yfm_block" | "yfm_html_block" | "yfm_layout" | "horizontalrule", string>;
 export declare const ActionName: Readonly<typeof namesObj>;
 export {};

package/build/esm/bundle/config/action-names.js

@@ -38,6 +38,7 @@ const names = [
     'math_block',
     'tabs',
     'mermaid',
+    'gpt',
 ];
 const namesObj = names.reduce((obj, val) => {
     obj[val] = val;

package/build/esm/bundle/config/icons.d.ts

@@ -1,5 +1,5 @@
 import { ToolbarIconData } from '../../toolbar/types';
-declare type Icon = 'undo' | 'redo' | 'bold' | 'italic' | 'underline' | 'strikethrough' | 'mono' | 'mark' | 'textColor' | 'text' | 'headline' | 'h1' | 'h2' | 'h3' | 'h4' | 'h5' | 'h6' | 'bulletList' | 'orderedList' | 'sink' | 'lift' | 'cut' | 'note' | 'code' | 'codeBlock' | 'link' | 'image' | 'table' | 'quote' | 'checklist' | 'horizontalRule' | 'file' | 'functionInline' | 'functionBlock' | 'emoji' | 'tabs' | 'mermaid' | 'html' | 'foldingHeading';
+declare type Icon = 'undo' | 'redo' | 'bold' | 'italic' | 'underline' | 'strikethrough' | 'mono' | 'mark' | 'textColor' | 'text' | 'headline' | 'h1' | 'h2' | 'h3' | 'h4' | 'h5' | 'h6' | 'bulletList' | 'orderedList' | 'sink' | 'lift' | 'cut' | 'note' | 'code' | 'codeBlock' | 'link' | 'image' | 'table' | 'quote' | 'checklist' | 'horizontalRule' | 'file' | 'functionInline' | 'functionBlock' | 'emoji' | 'tabs' | 'mermaid' | 'html' | 'foldingHeading' | 'gpt';
 declare type Icons = Record<Icon, ToolbarIconData>;
 export declare const icons: Icons;
 export {};

package/build/esm/bundle/config/icons.js

@@ -1,4 +1,5 @@
 import { BoldIcon, CheckListIcon, CodeBlockIcon, CodeInlineIcon, CutIcon, EmojiIcon, FileIcon, FoldingHeadingIcon, FunctionBlockIcon, FunctionInlineIcon, HRuleIcon, Heading1Icon, Heading2Icon, Heading3Icon, Heading4Icon, Heading5Icon, Heading6Icon, HeadingIcon, HtmlBlockIcon, ImageIcon, ItalicIcon, LiftIcon, LinkIcon, ListBlIcon, ListOlIcon, MarkIcon, MermaidIcon, MonoIcon, NoteIcon, QuoteIcon, RedoIcon, SinkIcon, StrikethroughIcon, TableIcon, TabsIcon, TextColorIcon, TextIcon, UnderlineIcon, UndoIcon, } from '../../icons';
+import GPTIcon from '../../icons/GPT';
 export const icons = {
     undo: { data: UndoIcon },
     redo: { data: RedoIcon },
@@ -39,4 +40,5 @@ export const icons = {
     tabs: { data: TabsIcon },
     mermaid: { data: MermaidIcon },
     foldingHeading: { data: FoldingHeadingIcon },
+    gpt: { data: GPTIcon },
 };

package/build/esm/bundle/config/wysiwyg.d.ts

@@ -45,6 +45,7 @@ export declare const wMathBlockItemData: WToolbarSingleItemData;
 export declare const wMathListConfig: WToolbarListButtonData;
 export declare const wMathListItem: WToolbarListItemData;
 export declare const wYfmHtmlBlockItemData: WToolbarSingleItemData;
+export declare const wGptItemData: WToolbarSingleItemData;
 export declare const wCommandMenuConfig: WToolbarItemData[];
 export declare const wHiddenData: WToolbarItemData[];
 /** prepared wysiwyg toolbar config */

package/build/esm/bundle/config/wysiwyg.js

@@ -1,4 +1,6 @@
 import { headingType, pType } from '../../extensions';
+// for typings from Math
+import { gptHotKeys } from '../../extensions/yfm/GPT/constants';
 import { i18n as i18nHint } from '../../i18n/hints';
 import { i18n } from '../../i18n/menubar';
 import { Action as A, formatter as f } from '../../shortcuts';
@@ -400,6 +402,16 @@ export const wYfmHtmlBlockItemData = {
     isActive: (e) => e.actions.createYfmHtmlBlock.isActive(),
     isEnable: (e) => e.actions.createYfmHtmlBlock.isEnable(),
 };
+export const wGptItemData = {
+    id: ActionName.gpt,
+    type: ToolbarDataType.SingleButton,
+    title: i18n.bind(null, 'gpt'),
+    hotkey: gptHotKeys.openGptKeyTooltip,
+    icon: icons.gpt,
+    exec: (e) => e.actions.addGptWidget.run({}),
+    isActive: (e) => e.actions.addGptWidget.isActive(),
+    isEnable: (e) => e.actions.addGptWidget.isEnable(),
+};
 export const wCommandMenuConfig = [
     ...wHeadingListConfig.data,
     ...wListsListConfig.data,

package/build/esm/extensions/markdown/Table/actions/innerActions.d.ts

@@ -1,2 +1,2 @@
 import { ActionSpec } from '../../../../core';
-export declare const innerActions: Record<"addRow" | "deleteRow" | "addColumn" | "deleteColumn" | "setCellLeftAlign" | "setCellCenterAlign" | "setCellRightAlign", ActionSpec>;
+export declare const innerActions: Record<"deleteRow" | "deleteColumn" | "setCellLeftAlign" | "setCellCenterAlign" | "setCellRightAlign" | "addRow" | "addColumn", ActionSpec>;

package/build/esm/extensions/yfm/GPT/ErrorScreen/ErrorScreen.css

@@ -0,0 +1,18 @@
+.g-md-gpt-dialog-error-screen__content {
+  display: flex;
+  align-items: center;
+  margin-bottom: var(--g-spacing-2);
+}
+.g-md-gpt-dialog-error-screen__icon {
+  color: var(--g-color-base-danger-heavy);
+}
+.g-md-gpt-dialog-error-screen__text {
+  flex: auto;
+  font-size: var(--g-text-body-2-font-size);
+  font-weight: 500;
+}
+.g-md-gpt-dialog-error-screen__buttons {
+  display: flex;
+  align-items: center;
+  gap: var(--g-spacing-2);
+}

package/build/esm/extensions/yfm/GPT/ErrorScreen/ErrorScreen.d.ts

@@ -0,0 +1,9 @@
+import type { FC } from 'react';
+import './ErrorScreen.css';
+declare type ErrorScreenProps = {
+    onRetry: () => void;
+    onStartAgain: () => void;
+};
+export declare const cnGptDialogErrorScreen: import("@bem-react/classname").ClassNameFormatter;
+export declare const ErrorScreen: FC<ErrorScreenProps>;
+export {};

package/build/esm/extensions/yfm/GPT/ErrorScreen/ErrorScreen.js

@@ -0,0 +1,17 @@
+import React from 'react';
+import { CircleXmarkFill } from '@gravity-ui/icons';
+import { Button } from '@gravity-ui/uikit';
+import { cn } from '../../../../classname';
+import { i18n } from '../../../../i18n/gpt/errors';
+import { IconRefuge } from '../IconRefuge/IconRefuge';
+import './ErrorScreen.css';
+export const cnGptDialogErrorScreen = cn('gpt-dialog-error-screen');
+export const ErrorScreen = ({ onRetry, onStartAgain }) => {
+    return (React.createElement("div", { className: cnGptDialogErrorScreen() },
+        React.createElement("div", { className: cnGptDialogErrorScreen('content') },
+            React.createElement(IconRefuge, { containerClassName: cnGptDialogErrorScreen('icon'), data: CircleXmarkFill, refugeSize: 28, size: 16 }),
+            React.createElement("span", { className: cnGptDialogErrorScreen('text') }, i18n('error-text'))),
+        React.createElement("div", { className: cnGptDialogErrorScreen('buttons') },
+            React.createElement(Button, { view: "normal", onClick: onStartAgain }, i18n('start-again-button')),
+            React.createElement(Button, { view: "normal", onClick: onRetry }, i18n('retry-button')))));
+};

package/build/esm/extensions/yfm/GPT/ErrorScreen/types.d.ts

@@ -0,0 +1,14 @@
+export declare type PromptPreset<PromptData extends unknown = unknown> = {
+    display: string;
+    key: string;
+    data?: PromptData;
+    hotKey?: string;
+};
+export declare type CommonAnswer = {
+    rawText: string;
+};
+export declare type GptRequestData<PromptData extends unknown = unknown> = {
+    markup: string;
+    customPrompt?: string;
+    promptData?: PromptData;
+};

package/build/esm/extensions/yfm/GPT/ErrorScreen/types.js

@@ -0,0 +1 @@
+export {};

package/build/esm/extensions/yfm/GPT/GptDialog/GptDialog.css

@@ -0,0 +1,75 @@
+.g-md-gpt-dialog__header-top {
+  display: flex;
+  align-items: center;
+}
+.g-md-gpt-dialog__custom-prompt-input {
+  margin-right: var(--g-spacing-2);
+}
+.g-md-gpt-dialog__custom-prompt-input .g-text-input__control {
+  font-size: var(--g-text-body-2-font-size);
+}
+.g-md-gpt-dialog__header-bottom {
+  margin-top: var(--g-spacing-2);
+}
+.g-md-gpt-dialog__custom-prompt {
+  display: flex;
+  flex: auto;
+  align-items: center;
+}
+.g-md-gpt-dialog__alone-presets-text {
+  margin-right: var(--g-spacing-8);
+}
+.g-md-gpt-dialog__alone-presets {
+  display: flex;
+  flex: auto;
+  align-items: center;
+  width: 100%;
+  font-size: var(--g-text-body-2-font-size);
+  font-weight: 500;
+}
+.g-md-gpt-dialog__alone-presets .g-md-gpt-dialog-preset-list {
+  flex: auto;
+}
+.g-md-gpt-dialog__answer-title {
+  font-size: var(--g-text-body-2-font-size);
+  font-weight: 500;
+}
+.g-md-gpt-dialog__gpt-icon {
+  margin-right: var(--g-spacing-1);
+}
+.g-md-gpt-dialog__try-again-button {
+  margin-right: var(--g-spacing-2);
+}
+.g-md-gpt-dialog__body {
+  margin: var(--g-spacing-2) calc(-1 * var(--g-spacing-3));
+  padding: var(--g-spacing-4) var(--g-spacing-3);
+  border-top: 1px solid var(--g-color-line-generic);
+}
+.g-md-gpt-dialog__answer {
+  overflow: auto;
+  max-height: 300px;
+}
+.g-md-gpt-dialog__answer-actions {
+  display: flex;
+  align-items: center;
+}
+.g-md-gpt-dialog__feedback-message {
+  margin-left: var(--g-spacing-2);
+}
+.g-md-gpt-dialog__like-button {
+  margin-right: var(--g-spacing-2);
+}
+.g-md-gpt-dialog__close-button {
+  margin-right: var(--g-spacing-2);
+  margin-left: auto;
+}
+.g-md-gpt-dialog__footer {
+  display: flex;
+  align-items: center;
+  margin-top: var(--g-spacing-2);
+}
+.g-md-gpt-dialog__description-alert {
+  min-height: 34px;
+  margin-top: var(--g-spacing-3);
+  padding: var(--g-spacing-1) var(--g-spacing-2);
+}

package/build/esm/extensions/yfm/GPT/GptDialog/GptDialog.d.ts

@@ -0,0 +1,29 @@
+import type { FC } from 'react';
+import { AlertProps } from '@gravity-ui/uikit';
+import type { CommonAnswer, GptRequestData, PromptPreset } from '../ErrorScreen/types';
+import './GptDialog.css';
+export declare type GptDialogProps<AnswerData extends CommonAnswer = CommonAnswer, PromptData extends unknown = unknown> = {
+    markup: string;
+    answerRender: (data: AnswerData) => JSX.Element;
+    onApplyResult: (markup: string) => void;
+    promptPresets?: PromptPreset<PromptData>[];
+    disablePromptPresets?: boolean;
+    customPromptPlaceholder?: string;
+    disabledPromptPlaceholder?: string;
+    onCustomPromptApply?: (data: GptRequestData<PromptData>) => Promise<AnswerData | undefined>;
+    onPromptPresetClick?: (data: GptRequestData<PromptData>) => Promise<AnswerData | undefined>;
+    onTryAgain?: (data: GptRequestData<PromptData>) => Promise<AnswerData | undefined>;
+    onLike?: (data: GptRequestData<PromptData>) => Promise<void>;
+    onDislike?: (data: GptRequestData<PromptData>) => Promise<void>;
+    onClose?: () => void;
+    onUpdate?: (value: AnswerData | undefined) => void;
+    gptAlertProps?: {
+        showedGptAlert: boolean;
+        onCloseGptAlert?: () => void;
+        message?: string;
+        theme?: AlertProps['theme'];
+        className?: string;
+    };
+};
+export declare const cnGptDialog: import("@bem-react/classname").ClassNameFormatter;
+export declare const GptDialog: FC<GptDialogProps>;