@gravity-ui/markdown-editor 13.0.0

package/build/esm/extensions/markdown/Lists/utils.js

@@ -0,0 +1,8 @@
+import { findParentNodeOfType } from 'prosemirror-utils';
+import { blType, liType, olType } from './ListsSpecs';
+export { liType, blType, olType } from './ListsSpecs';
+export const findAnyParentList = (schema) => findParentNodeOfType([blType(schema), olType(schema)]);
+export const isIntoListOfType = (nodeName) => (state) => { var _a; return ((_a = findAnyParentList(state.schema)(state.selection)) === null || _a === void 0 ? void 0 : _a.node.type.name) === nodeName; };
+export const isListNode = ({ type }) => type === blType(type.schema) || type === olType(type.schema);
+export const isListItemNode = (node) => node.type === liType(node.type.schema);
+export const isListOrItemNode = (node) => isListNode(node) || isListItemNode(node);

package/build/esm/extensions/markdown/Mark/MarkSpecs/index.d.ts

@@ -0,0 +1,4 @@
+import type { ExtensionAuto } from '../../../../core';
+export declare const markMarkName = "mark";
+export declare const markMarkType: (schema: import("prosemirror-model").Schema<any, any>) => import("prosemirror-model").MarkType;
+export declare const MarkSpecs: ExtensionAuto;

package/build/esm/extensions/markdown/Mark/MarkSpecs/index.js

@@ -0,0 +1,28 @@
+import markPlugin from 'markdown-it-mark';
+import { markTypeFactory } from '../../../../utils/schema';
+export const markMarkName = 'mark';
+export const markMarkType = markTypeFactory(markMarkName);
+export const MarkSpecs = (builder) => {
+    builder
+        .configureMd((md) => md.use(markPlugin))
+        .addMark(markMarkName, () => ({
+        spec: {
+            parseDOM: [{ tag: 'mark' }],
+            toDOM() {
+                return ['mark'];
+            },
+        },
+        fromMd: {
+            tokenSpec: {
+                name: markMarkName,
+                type: 'mark',
+            },
+        },
+        toMd: {
+            open: '==',
+            close: '==',
+            mixable: true,
+            expelEnclosingWhitespace: true,
+        },
+    }));
+};

package/build/esm/extensions/markdown/Mark/index.d.ts

@@ -0,0 +1,13 @@
+import type { Action, ExtensionAuto } from '../../../core';
+export { markMarkName, markMarkType } from './MarkSpecs';
+/** @deprecated Use `markMarkName` instead  */
+export declare const mark = "mark";
+declare const mAction = "mark";
+export declare const Mark: ExtensionAuto;
+declare global {
+    namespace WysiwygEditor {
+        interface Actions {
+            [mAction]: Action;
+        }
+    }
+}

package/build/esm/extensions/markdown/Mark/index.js

@@ -0,0 +1,17 @@
+import { createToggleMarkAction } from '../../../utils/actions';
+import { markInputRule } from '../../../utils/inputrules';
+import { MarkSpecs, markMarkName, markMarkType } from './MarkSpecs';
+export { markMarkName, markMarkType } from './MarkSpecs';
+/** @deprecated Use `markMarkName` instead  */
+export const mark = markMarkName;
+const mAction = 'mark';
+export const Mark = (builder) => {
+    builder.use(MarkSpecs);
+    builder
+        .addAction(mAction, ({ schema }) => createToggleMarkAction(markMarkType(schema)))
+        .addInputRules(({ schema }) => ({
+        rules: [
+            markInputRule({ open: '==', close: '==', ignoreBetween: '=' }, markMarkType(schema)),
+        ],
+    }));
+};

package/build/esm/extensions/markdown/Strike/StrikeSpecs/index.d.ts

@@ -0,0 +1,4 @@
+import type { ExtensionAuto } from '../../../../core';
+export declare const strikeMarkName = "strike";
+export declare const strikeType: (schema: import("prosemirror-model").Schema<any, any>) => import("prosemirror-model").MarkType;
+export declare const StrikeSpecs: ExtensionAuto;

package/build/esm/extensions/markdown/Strike/StrikeSpecs/index.js

@@ -0,0 +1,21 @@
+import { markTypeFactory } from '../../../../utils/schema';
+export const strikeMarkName = 'strike';
+export const strikeType = markTypeFactory(strikeMarkName);
+export const StrikeSpecs = (builder) => {
+    builder.addMark(strikeMarkName, () => ({
+        spec: {
+            parseDOM: [{ tag: 'strike' }, { tag: 's' }],
+            toDOM() {
+                return ['strike'];
+            },
+        },
+        fromMd: {
+            tokenSpec: {
+                name: strikeMarkName,
+                type: 'mark',
+            },
+            tokenName: 's',
+        },
+        toMd: { open: '~~', close: '~~', mixable: true, expelEnclosingWhitespace: true },
+    }));
+};

package/build/esm/extensions/markdown/Strike/index.d.ts

@@ -0,0 +1,16 @@
+import type { Action, ExtensionAuto } from '../../../core';
+export { strikeMarkName, strikeType } from './StrikeSpecs';
+/** @deprecated Use `strikeMarkName` instead */
+export declare const strike = "strike";
+declare const sAction = "strike";
+export declare type StrikeOptions = {
+    strikeKey?: string | null;
+};
+export declare const Strike: ExtensionAuto<StrikeOptions>;
+declare global {
+    namespace WysiwygEditor {
+        interface Actions {
+            [sAction]: Action;
+        }
+    }
+}

package/build/esm/extensions/markdown/Strike/index.js

@@ -0,0 +1,25 @@
+import { toggleMark } from 'prosemirror-commands';
+import { createToggleMarkAction } from '../../../utils/actions';
+import { markInputRule } from '../../../utils/inputrules';
+import { withLogAction } from '../../../utils/keymap';
+import { StrikeSpecs, strikeMarkName, strikeType } from './StrikeSpecs';
+export { strikeMarkName, strikeType } from './StrikeSpecs';
+/** @deprecated Use `strikeMarkName` instead */
+export const strike = strikeMarkName;
+const sAction = 'strike';
+export const Strike = (builder, opts) => {
+    builder.use(StrikeSpecs);
+    builder
+        .addAction(sAction, ({ schema }) => createToggleMarkAction(strikeType(schema)))
+        .addInputRules(({ schema }) => ({
+        rules: [
+            markInputRule({ open: '~~', close: '~~', ignoreBetween: '~' }, strikeType(schema)),
+        ],
+    }));
+    if (opts === null || opts === void 0 ? void 0 : opts.strikeKey) {
+        const { strikeKey } = opts;
+        builder.addKeymap(({ schema }) => ({
+            [strikeKey]: withLogAction('strike', toggleMark(strikeType(schema))),
+        }));
+    }
+};

package/build/esm/extensions/markdown/Subscript/SubscriptSpecs/index.d.ts

@@ -0,0 +1,4 @@
+import type { ExtensionAuto } from '../../../../core';
+export declare const subscriptMarkName = "sub";
+export declare const subscriptType: (schema: import("prosemirror-model").Schema<any, any>) => import("prosemirror-model").MarkType;
+export declare const SubscriptSpecs: ExtensionAuto;

package/build/esm/extensions/markdown/Subscript/SubscriptSpecs/index.js

@@ -0,0 +1,30 @@
+import subPlugin from 'markdown-it-sub';
+import { markTypeFactory } from '../../../../utils/schema';
+export const subscriptMarkName = 'sub';
+export const subscriptType = markTypeFactory(subscriptMarkName);
+export const SubscriptSpecs = (builder) => {
+    builder
+        .configureMd((md) => md.use(subPlugin))
+        .addMark(subscriptMarkName, () => ({
+        spec: {
+            excludes: '_',
+            parseDOM: [{ tag: 'sub' }],
+            toDOM() {
+                return ['sub'];
+            },
+        },
+        toMd: {
+            open: (state) => {
+                state.escapeWhitespace = true;
+                return '~';
+            },
+            close: (state) => {
+                state.escapeWhitespace = false;
+                return '~';
+            },
+            mixable: false,
+            expelEnclosingWhitespace: true,
+        },
+        fromMd: { tokenSpec: { name: subscriptMarkName, type: 'mark' } },
+    }));
+};

package/build/esm/extensions/markdown/Subscript/index.d.ts

@@ -0,0 +1,13 @@
+import type { Action, ExtensionAuto } from '../../../core';
+export { subscriptMarkName, subscriptType } from './SubscriptSpecs';
+/** @deprecated Use `subscriptMarkName` instead */
+export declare const subscript = "sub";
+declare const subAction = "subscript";
+export declare const Subscript: ExtensionAuto;
+declare global {
+    namespace WysiwygEditor {
+        interface Actions {
+            [subAction]: Action;
+        }
+    }
+}

package/build/esm/extensions/markdown/Subscript/index.js

@@ -0,0 +1,17 @@
+import { createToggleMarkAction } from '../../../utils/actions';
+import { markInputRule } from '../../../utils/inputrules';
+import { SubscriptSpecs, subscriptMarkName, subscriptType } from './SubscriptSpecs';
+export { subscriptMarkName, subscriptType } from './SubscriptSpecs';
+/** @deprecated Use `subscriptMarkName` instead */
+export const subscript = subscriptMarkName;
+const subAction = 'subscript';
+export const Subscript = (builder) => {
+    builder.use(SubscriptSpecs);
+    builder
+        .addAction(subAction, ({ schema }) => createToggleMarkAction(subscriptType(schema)))
+        .addInputRules(({ schema }) => ({
+        rules: [
+            markInputRule({ open: '~', close: '~', ignoreBetween: '~' }, subscriptType(schema)),
+        ],
+    }));
+};

package/build/esm/extensions/markdown/Superscript/SuperscriptSpecs/index.d.ts

@@ -0,0 +1,4 @@
+import type { ExtensionAuto } from '../../../../core';
+export declare const superscriptMarkName = "sup";
+export declare const superscriptType: (schema: import("prosemirror-model").Schema<any, any>) => import("prosemirror-model").MarkType;
+export declare const SuperscriptSpecs: ExtensionAuto;

package/build/esm/extensions/markdown/Superscript/SuperscriptSpecs/index.js

@@ -0,0 +1,31 @@
+import log from '@diplodoc/transform/lib/log';
+import sup from '@diplodoc/transform/lib/plugins/sup';
+import { markTypeFactory } from '../../../../utils/schema';
+export const superscriptMarkName = 'sup';
+export const superscriptType = markTypeFactory(superscriptMarkName);
+export const SuperscriptSpecs = (builder) => {
+    builder
+        .configureMd((md) => md.use(sup, { log }))
+        .addMark(superscriptMarkName, () => ({
+        spec: {
+            excludes: '_',
+            parseDOM: [{ tag: 'sup' }],
+            toDOM() {
+                return ['sup'];
+            },
+        },
+        toMd: {
+            open: (state) => {
+                state.escapeWhitespace = true;
+                return '^';
+            },
+            close: (state) => {
+                state.escapeWhitespace = false;
+                return '^';
+            },
+            mixable: true,
+            expelEnclosingWhitespace: true,
+        },
+        fromMd: { tokenSpec: { name: superscriptMarkName, type: 'mark' } },
+    }));
+};

package/build/esm/extensions/markdown/Superscript/index.d.ts

@@ -0,0 +1,13 @@
+import type { Action, ExtensionAuto } from '../../../core';
+export { superscriptMarkName, superscriptType } from './SuperscriptSpecs';
+/** @deprecated Use `superscriptMarkName` instead */
+export declare const superscript = "sup";
+declare const supAction = "supscript";
+export declare const Superscript: ExtensionAuto;
+declare global {
+    namespace WysiwygEditor {
+        interface Actions {
+            [supAction]: Action;
+        }
+    }
+}

package/build/esm/extensions/markdown/Superscript/index.js

@@ -0,0 +1,17 @@
+import { createToggleMarkAction } from '../../../utils/actions';
+import { markInputRule } from '../../../utils/inputrules';
+import { SuperscriptSpecs, superscriptMarkName, superscriptType } from './SuperscriptSpecs';
+export { superscriptMarkName, superscriptType } from './SuperscriptSpecs';
+/** @deprecated Use `superscriptMarkName` instead */
+export const superscript = superscriptMarkName;
+const supAction = 'supscript';
+export const Superscript = (builder) => {
+    builder.use(SuperscriptSpecs);
+    builder
+        .addAction(supAction, ({ schema }) => createToggleMarkAction(superscriptType(schema)))
+        .addInputRules(({ schema }) => ({
+        rules: [
+            markInputRule({ open: '^', close: '^', ignoreBetween: '^' }, superscriptType(schema)),
+        ],
+    }));
+};

package/build/esm/extensions/markdown/Table/TableSpecs/const.d.ts

@@ -0,0 +1,16 @@
+export declare enum TableNode {
+    Table = "table",
+    Head = "thead",
+    Body = "tbody",
+    Row = "tr",
+    HeaderCell = "th",
+    DataCell = "td"
+}
+export declare enum TableAttrs {
+    CellAlign = "cell-align"
+}
+export declare enum CellAlign {
+    Left = "left",
+    Center = "center",
+    Right = "right"
+}

package/build/esm/extensions/markdown/Table/TableSpecs/const.js

@@ -0,0 +1,19 @@
+export var TableNode;
+(function (TableNode) {
+    TableNode["Table"] = "table";
+    TableNode["Head"] = "thead";
+    TableNode["Body"] = "tbody";
+    TableNode["Row"] = "tr";
+    TableNode["HeaderCell"] = "th";
+    TableNode["DataCell"] = "td";
+})(TableNode || (TableNode = {}));
+export var TableAttrs;
+(function (TableAttrs) {
+    TableAttrs["CellAlign"] = "cell-align";
+})(TableAttrs || (TableAttrs = {}));
+export var CellAlign;
+(function (CellAlign) {
+    CellAlign["Left"] = "left";
+    CellAlign["Center"] = "center";
+    CellAlign["Right"] = "right";
+})(CellAlign || (CellAlign = {}));

package/build/esm/extensions/markdown/Table/TableSpecs/index.d.ts

@@ -0,0 +1,3 @@
+import type { ExtensionAuto } from '../../../../core';
+export { TableNode } from './const';
+export declare const TableSpecs: ExtensionAuto;

package/build/esm/extensions/markdown/Table/TableSpecs/index.js

@@ -0,0 +1,38 @@
+import { TableNode } from './const';
+import { parserTokens } from './parser';
+import { schemaSpecs } from './schema';
+import { serializerTokens } from './serializer';
+export { TableNode } from './const';
+export const TableSpecs = (builder) => {
+    builder
+        .addNode(TableNode.Table, () => ({
+        spec: schemaSpecs[TableNode.Table],
+        toMd: serializerTokens[TableNode.Table],
+        fromMd: { tokenSpec: parserTokens[TableNode.Table] },
+    }))
+        .addNode(TableNode.Head, () => ({
+        spec: schemaSpecs[TableNode.Head],
+        toMd: serializerTokens[TableNode.Head],
+        fromMd: { tokenSpec: parserTokens[TableNode.Head] },
+    }))
+        .addNode(TableNode.Body, () => ({
+        spec: schemaSpecs[TableNode.Body],
+        toMd: serializerTokens[TableNode.Body],
+        fromMd: { tokenSpec: parserTokens[TableNode.Body] },
+    }))
+        .addNode(TableNode.Row, () => ({
+        spec: schemaSpecs[TableNode.Row],
+        toMd: serializerTokens[TableNode.Row],
+        fromMd: { tokenSpec: parserTokens[TableNode.Row] },
+    }))
+        .addNode(TableNode.HeaderCell, () => ({
+        spec: schemaSpecs[TableNode.HeaderCell],
+        toMd: serializerTokens[TableNode.HeaderCell],
+        fromMd: { tokenSpec: parserTokens[TableNode.HeaderCell] },
+    }))
+        .addNode(TableNode.DataCell, () => ({
+        spec: schemaSpecs[TableNode.DataCell],
+        toMd: serializerTokens[TableNode.DataCell],
+        fromMd: { tokenSpec: parserTokens[TableNode.DataCell] },
+    }));
+};

package/build/esm/extensions/markdown/Table/TableSpecs/parser.d.ts

@@ -0,0 +1,3 @@
+import type { ParserToken } from '../../../../core';
+import { TableNode } from '../const';
+export declare const parserTokens: Record<TableNode, ParserToken>;

package/build/esm/extensions/markdown/Table/TableSpecs/parser.js

@@ -0,0 +1,23 @@
+import { CellAlign, TableAttrs, TableNode } from '../const';
+export const parserTokens = {
+    [TableNode.Table]: { name: TableNode.Table, type: 'block' },
+    [TableNode.Head]: { name: TableNode.Head, type: 'block' },
+    [TableNode.Body]: { name: TableNode.Body, type: 'block' },
+    [TableNode.Row]: { name: TableNode.Row, type: 'block' },
+    [TableNode.HeaderCell]: {
+        name: TableNode.HeaderCell,
+        type: 'block',
+        getAttrs: getTableCellAttrs,
+    },
+    [TableNode.DataCell]: { name: TableNode.DataCell, type: 'block', getAttrs: getTableCellAttrs },
+};
+function getTableCellAttrs({ attrs }) {
+    const objAttrs = Object.fromEntries(attrs || []);
+    let align = CellAlign.Left;
+    if (objAttrs.style) {
+        const styles = objAttrs.style.split(';');
+        const textAlignStyle = styles.find((str) => str.startsWith('text-align:')) || '';
+        [, align = CellAlign.Left] = textAlignStyle.split(':');
+    }
+    return { [TableAttrs.CellAlign]: align };
+}

package/build/esm/extensions/markdown/Table/TableSpecs/schema.d.ts

@@ -0,0 +1,3 @@
+import type { NodeSpec } from 'prosemirror-model';
+import { TableNode } from '../const';
+export declare const schemaSpecs: Record<TableNode, NodeSpec>;

package/build/esm/extensions/markdown/Table/TableSpecs/schema.js

@@ -0,0 +1,89 @@
+import { TableRole } from '../../../../table-utils';
+import { CellAlign, TableAttrs, TableNode } from '../const';
+export const schemaSpecs = {
+    [TableNode.Table]: {
+        group: 'block',
+        content: `${TableNode.Head} ${TableNode.Body}`,
+        isolating: true,
+        parseDOM: [{ tag: 'table' }],
+        toDOM() {
+            return ['table', 0];
+        },
+        selectable: true,
+        allowSelection: true,
+        tableRole: TableRole.Table,
+        complex: 'root',
+    },
+    [TableNode.Head]: {
+        group: 'block',
+        content: TableNode.Row,
+        isolating: true,
+        parseDOM: [{ tag: 'thead' }],
+        toDOM() {
+            return ['thead', 0];
+        },
+        tableRole: TableRole.Body,
+        selectable: false,
+        allowSelection: false,
+        complex: 'inner',
+    },
+    [TableNode.Body]: {
+        group: 'block',
+        content: `${TableNode.Row}+`,
+        isolating: true,
+        parseDOM: [{ tag: 'tbody' }],
+        toDOM() {
+            return ['tbody', 0];
+        },
+        tableRole: TableRole.Body,
+        selectable: false,
+        allowSelection: false,
+        complex: 'inner',
+    },
+    [TableNode.Row]: {
+        group: 'block',
+        content: `(${TableNode.HeaderCell}|${TableNode.DataCell})+`,
+        isolating: true,
+        parseDOM: [{ tag: 'tr' }],
+        toDOM() {
+            return ['tr', 0];
+        },
+        tableRole: TableRole.Row,
+        selectable: false,
+        allowSelection: false,
+        complex: 'inner',
+    },
+    [TableNode.HeaderCell]: cellTemplate('th'),
+    [TableNode.DataCell]: cellTemplate('td'),
+};
+function cellTemplate(tag) {
+    return {
+        attrs: { [TableAttrs.CellAlign]: { default: CellAlign.Left } },
+        group: 'block',
+        content: '(text | inline)*',
+        isolating: true,
+        parseDOM: [
+            {
+                tag,
+                getAttrs(dom) {
+                    if (!dom.hasAttribute(TableAttrs.CellAlign))
+                        return null;
+                    return {
+                        [TableAttrs.CellAlign]: dom.getAttribute(TableAttrs.CellAlign),
+                    };
+                },
+            },
+        ],
+        toDOM({ attrs }) {
+            return [
+                tag,
+                Object.assign(Object.assign({}, attrs), { style: `text-align:${attrs[TableAttrs.CellAlign]}` }),
+                0,
+            ];
+        },
+        tableRole: TableRole.Cell,
+        selectable: false,
+        allowSelection: false,
+        complex: 'leaf',
+    };
+}

package/build/esm/extensions/markdown/Table/TableSpecs/serializer.d.ts

@@ -0,0 +1,3 @@
+import type { SerializerNodeToken } from '../../../../core';
+import { TableNode } from '../const';
+export declare const serializerTokens: Record<TableNode, SerializerNodeToken>;

package/build/esm/extensions/markdown/Table/TableSpecs/serializer.js

@@ -0,0 +1,55 @@
+import { CellAlign, TableAttrs, TableNode } from '../const';
+export const serializerTokens = {
+    [TableNode.Table]: (state, node) => {
+        state.ensureNewLine();
+        state.write('\n');
+        state.setNoAutoBlank();
+        state.renderContent(node);
+        state.unsetNoAutoBlank();
+        state.ensureNewLine();
+        state.closeBlock(node);
+    },
+    [TableNode.Head]: (state, node) => {
+        state.renderContent(node);
+        // @ts-expect-error
+        for (const cellNode of node.content.content[0].content.content) {
+            switch (cellNode.attrs[TableAttrs.CellAlign]) {
+                case CellAlign.Left:
+                    state.write('|:---');
+                    break;
+                case CellAlign.Center:
+                    state.write('|:---:');
+                    break;
+                case CellAlign.Right:
+                    state.write('|---:');
+                    break;
+                default:
+                    state.write('|---');
+                    break;
+            }
+        }
+        state.write('|');
+        state.ensureNewLine();
+        state.closeBlock(node);
+    },
+    [TableNode.Body]: (state, node) => {
+        state.renderContent(node);
+        state.closeBlock(node);
+    },
+    [TableNode.Row]: (state, node) => {
+        state.renderContent(node);
+        state.closeBlock(node);
+        state.write('|');
+        state.ensureNewLine();
+    },
+    [TableNode.HeaderCell]: (state, node) => {
+        state.write('|');
+        state.renderInline(node);
+        state.closeBlock(node);
+    },
+    [TableNode.DataCell]: (state, node) => {
+        state.write('|');
+        state.renderInline(node);
+        state.closeBlock(node);
+    },
+};

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

@@ -0,0 +1,4 @@
+import { ActionSpec } from '../../../../core';
+export declare const setCellLeftAlign: ActionSpec;
+export declare const setCellCenterAlign: ActionSpec;
+export declare const setCellRightAlign: ActionSpec;

package/build/esm/extensions/markdown/Table/actions/cellAlign.js

@@ -0,0 +1,43 @@
+import { CellAlign, TableAttrs } from '../TableSpecs/const';
+import { findParentCell, findParentRow, findParentTable, findTableCells, findTableRows, isIntoTable, } from '../helpers';
+function factory(align) {
+    return {
+        isActive(state) {
+            const cell = findParentCell(state);
+            return (cell === null || cell === void 0 ? void 0 : cell.node.attrs[TableAttrs.CellAlign]) === align;
+        },
+        isEnable(state) {
+            return isIntoTable(state);
+        },
+        run(state, dispatch) {
+            const table = findParentTable(state);
+            const row = findParentRow(state);
+            const cell = findParentCell(state);
+            if (!cell || !row || !table) {
+                return;
+            }
+            let cellIndex = -1;
+            row.node.forEach((node, _, index) => {
+                if (node === cell.node) {
+                    cellIndex = index;
+                }
+            });
+            if (cellIndex < 0) {
+                return;
+            }
+            const tr = state.tr;
+            const allRows = findTableRows(table.node, state.schema);
+            for (const row of allRows) {
+                const rowCells = findTableCells(row.node, state.schema);
+                const cell = rowCells[cellIndex];
+                // mmm, magic numbers ^_^
+                const pos = table.pos + row.pos + cell.pos + 2;
+                tr.setNodeMarkup(pos, undefined, Object.assign(Object.assign({}, cell.node.attrs), { [TableAttrs.CellAlign]: align }));
+            }
+            dispatch(tr);
+        },
+    };
+}
+export const setCellLeftAlign = factory(CellAlign.Left);
+export const setCellCenterAlign = factory(CellAlign.Center);
+export const setCellRightAlign = factory(CellAlign.Right);

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

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

package/build/esm/extensions/markdown/Table/actions/innerActions.js

@@ -0,0 +1,35 @@
+import { addColumnAfter, addRowAfter as addRowAfterOrig, removeCurrentColumn, removeCurrentRow, } from '../../../../table-utils';
+import { defineActions } from '../../../../utils/actions';
+import { findParentBody } from '../helpers';
+import { setCellCenterAlign, setCellLeftAlign, setCellRightAlign } from './cellAlign';
+const addRowAfter = (state, dispatch, view) => {
+    if (!findParentBody(state)) {
+        return false; // TODO: process when cursor is inside thead
+    }
+    return addRowAfterOrig(state, dispatch, view);
+};
+const addRow = {
+    isEnable: addRowAfter,
+    run: addRowAfter,
+};
+const deleteRow = {
+    isEnable: removeCurrentRow,
+    run: removeCurrentRow,
+};
+const addColumn = {
+    isEnable: addColumnAfter,
+    run: addColumnAfter,
+};
+const deleteColumn = {
+    isEnable: removeCurrentColumn,
+    run: removeCurrentColumn,
+};
+export const innerActions = defineActions({
+    setCellLeftAlign,
+    setCellCenterAlign,
+    setCellRightAlign,
+    addRow,
+    deleteRow,
+    addColumn,
+    deleteColumn,
+});

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

@@ -0,0 +1,3 @@
+import type { ActionSpec, ExtensionDeps } from '../../../../core';
+export declare const createTableAction: ({ markupParser }: ExtensionDeps) => ActionSpec;
+export declare const deleteTableAction: ActionSpec;