@gravity-ui/markdown-editor 13.17.1 → 13.18.1

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

@@ -0,0 +1,144 @@
+import isNumber from 'is-number';
+import { isTableBodyNode, isTableNode } from './utils';
+export 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 (!isTableNode(table))
+            return null;
+        const tbody = table.lastChild;
+        if (!tbody || !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 (isNumber(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 (isNumber(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;
+    }
+}
+TableDesc.__cache = new WeakMap();

package/build/esm/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/esm/table-utils/utils.js

@@ -1,4 +1,4 @@
-import { Node as PmNode } from 'prosemirror-model';
+import isNumber from 'is-number';
 import { findChildren, findParentNode, findParentNodeClosestToPos, } from 'prosemirror-utils';
 import { isTextSelection } from '../utils/selection';
 import { TableRole } from './const';
@@ -18,17 +18,23 @@ export const findChildTableRows = (node) => findChildren(node, isTableRowNode);
 export const findChildTableCells = (node) => findChildren(node, isTableCellNode);
 export const findChildTableBody = (node) => findChildren(node, isTableBodyNode);
 export const getTableDimensions = (node) => {
-    var _a, _b, _c, _d, _e, _f;
-    let rows, cols;
-    if (node instanceof PmNode) {
-        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 (isNumber(cellAttrs['colspan'])) {
+                    cols += parseInt(cellAttrs['colspan'], 10);
+                }
+                else {
+                    cols++;
+                }
+            });
+        }
+    });
+    return { rows, cols };
 };
 export function atEndOfCell(view, dir) {
     if (!isTextSelection(view.state.selection))

package/build/esm/version.js

@@ -1,2 +1,2 @@
 /** During build process, the current version will be injected here */
-export const VERSION = typeof '13.17.1' !== 'undefined' ? '13.17.1' : 'unknown';
+export const VERSION = typeof '13.18.1' !== 'undefined' ? '13.18.1' : 'unknown';

package/build/styles.css

@@ -1242,6 +1242,130 @@ body :has(.g-md-resizable_resizing) {
   line-height: var(--g-text-body-1-line-height);
   font-weight: var(--g-text-body-font-weight);
 }
+.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);
+}
+.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);
+}
+.icon-refuge {
+  display: inline-flex;
+  justify-content: center;
+  align-items: center;
+}
+.icon-refuge_inline {
+  display: inline-flex;
+}
+.g-md-gpt-dialog-preset-list__preset + .g-md-gpt-dialog-preset-list__preset {
+  margin-left: var(--g-spacing-2);
+}
+.g-md-gpt-dialog-preset-list__more-button-wrapper {
+  margin-left: var(--g-spacing-2);
+}
+.g-md-gpt-widget-deco {
+  background-color: var(--g-color-base-info-light-hover);
+}
+
+.g-md-gpt-popup {
+  --layer-navigation-bar: 900;
+  pointer-events: initial;
+}
+.g-md-gpt-popup[class] {
+  border-radius: var(--g-spacing-2);
+}
+.g-md-gpt-popup__content {
+  width: 720px;
+  padding: var(--g-spacing-3);
+  pointer-events: all;
+  box-shadow: -8px 2px 16px -4px var(--g-color-private-purple-150), 8px 2px 16px -4px var(--g-color-private-blue-150);
+}
 .g-md-image-skeleton {
   vertical-align: middle;
 }
@@ -1425,6 +1549,28 @@ body :has(.g-md-resizable_resizing) {
 .table-cell-floating-icon {
   transform: rotate(90deg);
 }
+.g-md-gpt-dialog-loading-screen__header {
+  display: flex;
+  align-items: center;
+  margin-bottom: 8px;
+}
+.g-md-gpt-dialog-loading-screen__icon {
+  margin-right: 4px;
+}
+.g-md-gpt-dialog-loading-screen__text {
+  margin-right: 8px;
+  font-size: var(--g-text-body-2-font-size);
+  font-weight: 500;
+}
+.g-md-gpt-dialog-loading-screen__skeleton-small-button {
+  width: 90px;
+  height: 28px;
+  margin-right: 8px;
+}
+.g-md-gpt-dialog-loading-screen__skeleton-medium-button {
+  width: 120px;
+  height: 28px;
+}
 .g-md-img-size-node-view__wrapper {
   position: relative;
   display: inline-block;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gravity-ui/markdown-editor",
-  "version": "13.17.1",
+  "version": "13.18.1",
   "description": "Markdown wysiwyg and markup editor",
   "license": "MIT",
   "repository": {
@@ -195,6 +195,7 @@
     "prosemirror-utils": "1.2.0",
     "prosemirror-view": "1.33.6",
     "react-error-boundary": "^3.1.4",
+    "react-hotkeys-hook": "4.5.0",
     "react-use": "^17.3.2",
     "tslib": "^2.3.1"
   },