@gravity-ui/markdown-editor 13.0.0

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

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Strike = exports.strike = exports.strikeType = exports.strikeMarkName = void 0;
+const prosemirror_commands_1 = require("prosemirror-commands");
+const actions_1 = require("../../../utils/actions");
+const inputrules_1 = require("../../../utils/inputrules");
+const keymap_1 = require("../../../utils/keymap");
+const StrikeSpecs_1 = require("./StrikeSpecs");
+var StrikeSpecs_2 = require("./StrikeSpecs");
+Object.defineProperty(exports, "strikeMarkName", { enumerable: true, get: function () { return StrikeSpecs_2.strikeMarkName; } });
+Object.defineProperty(exports, "strikeType", { enumerable: true, get: function () { return StrikeSpecs_2.strikeType; } });
+/** @deprecated Use `strikeMarkName` instead */
+exports.strike = StrikeSpecs_1.strikeMarkName;
+const sAction = 'strike';
+const Strike = (builder, opts) => {
+    builder.use(StrikeSpecs_1.StrikeSpecs);
+    builder
+        .addAction(sAction, ({ schema }) => (0, actions_1.createToggleMarkAction)((0, StrikeSpecs_1.strikeType)(schema)))
+        .addInputRules(({ schema }) => ({
+        rules: [
+            (0, inputrules_1.markInputRule)({ open: '~~', close: '~~', ignoreBetween: '~' }, (0, StrikeSpecs_1.strikeType)(schema)),
+        ],
+    }));
+    if (opts === null || opts === void 0 ? void 0 : opts.strikeKey) {
+        const { strikeKey } = opts;
+        builder.addKeymap(({ schema }) => ({
+            [strikeKey]: (0, keymap_1.withLogAction)('strike', (0, prosemirror_commands_1.toggleMark)((0, StrikeSpecs_1.strikeType)(schema))),
+        }));
+    }
+};
+exports.Strike = Strike;

package/build/cjs/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/cjs/extensions/markdown/Subscript/SubscriptSpecs/index.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SubscriptSpecs = exports.subscriptType = exports.subscriptMarkName = void 0;
+const tslib_1 = require("tslib");
+const markdown_it_sub_1 = tslib_1.__importDefault(require("markdown-it-sub"));
+const schema_1 = require("../../../../utils/schema");
+exports.subscriptMarkName = 'sub';
+exports.subscriptType = (0, schema_1.markTypeFactory)(exports.subscriptMarkName);
+const SubscriptSpecs = (builder) => {
+    builder
+        .configureMd((md) => md.use(markdown_it_sub_1.default))
+        .addMark(exports.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: exports.subscriptMarkName, type: 'mark' } },
+    }));
+};
+exports.SubscriptSpecs = SubscriptSpecs;

package/build/cjs/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/cjs/extensions/markdown/Subscript/index.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Subscript = exports.subscript = exports.subscriptType = exports.subscriptMarkName = void 0;
+const actions_1 = require("../../../utils/actions");
+const inputrules_1 = require("../../../utils/inputrules");
+const SubscriptSpecs_1 = require("./SubscriptSpecs");
+var SubscriptSpecs_2 = require("./SubscriptSpecs");
+Object.defineProperty(exports, "subscriptMarkName", { enumerable: true, get: function () { return SubscriptSpecs_2.subscriptMarkName; } });
+Object.defineProperty(exports, "subscriptType", { enumerable: true, get: function () { return SubscriptSpecs_2.subscriptType; } });
+/** @deprecated Use `subscriptMarkName` instead */
+exports.subscript = SubscriptSpecs_1.subscriptMarkName;
+const subAction = 'subscript';
+const Subscript = (builder) => {
+    builder.use(SubscriptSpecs_1.SubscriptSpecs);
+    builder
+        .addAction(subAction, ({ schema }) => (0, actions_1.createToggleMarkAction)((0, SubscriptSpecs_1.subscriptType)(schema)))
+        .addInputRules(({ schema }) => ({
+        rules: [
+            (0, inputrules_1.markInputRule)({ open: '~', close: '~', ignoreBetween: '~' }, (0, SubscriptSpecs_1.subscriptType)(schema)),
+        ],
+    }));
+};
+exports.Subscript = Subscript;

package/build/cjs/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/cjs/extensions/markdown/Superscript/SuperscriptSpecs/index.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SuperscriptSpecs = exports.superscriptType = exports.superscriptMarkName = void 0;
+const tslib_1 = require("tslib");
+const log_1 = tslib_1.__importDefault(require("@diplodoc/transform/lib/log"));
+const sup_1 = tslib_1.__importDefault(require("@diplodoc/transform/lib/plugins/sup"));
+const schema_1 = require("../../../../utils/schema");
+exports.superscriptMarkName = 'sup';
+exports.superscriptType = (0, schema_1.markTypeFactory)(exports.superscriptMarkName);
+const SuperscriptSpecs = (builder) => {
+    builder
+        .configureMd((md) => md.use(sup_1.default, { log: log_1.default }))
+        .addMark(exports.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: exports.superscriptMarkName, type: 'mark' } },
+    }));
+};
+exports.SuperscriptSpecs = SuperscriptSpecs;

package/build/cjs/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/cjs/extensions/markdown/Superscript/index.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Superscript = exports.superscript = exports.superscriptType = exports.superscriptMarkName = void 0;
+const actions_1 = require("../../../utils/actions");
+const inputrules_1 = require("../../../utils/inputrules");
+const SuperscriptSpecs_1 = require("./SuperscriptSpecs");
+var SuperscriptSpecs_2 = require("./SuperscriptSpecs");
+Object.defineProperty(exports, "superscriptMarkName", { enumerable: true, get: function () { return SuperscriptSpecs_2.superscriptMarkName; } });
+Object.defineProperty(exports, "superscriptType", { enumerable: true, get: function () { return SuperscriptSpecs_2.superscriptType; } });
+/** @deprecated Use `superscriptMarkName` instead */
+exports.superscript = SuperscriptSpecs_1.superscriptMarkName;
+const supAction = 'supscript';
+const Superscript = (builder) => {
+    builder.use(SuperscriptSpecs_1.SuperscriptSpecs);
+    builder
+        .addAction(supAction, ({ schema }) => (0, actions_1.createToggleMarkAction)((0, SuperscriptSpecs_1.superscriptType)(schema)))
+        .addInputRules(({ schema }) => ({
+        rules: [
+            (0, inputrules_1.markInputRule)({ open: '^', close: '^', ignoreBetween: '^' }, (0, SuperscriptSpecs_1.superscriptType)(schema)),
+        ],
+    }));
+};
+exports.Superscript = Superscript;

package/build/cjs/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/cjs/extensions/markdown/Table/TableSpecs/const.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CellAlign = exports.TableAttrs = exports.TableNode = void 0;
+var TableNode;
+(function (TableNode) {
+    TableNode["Table"] = "table";
+    TableNode["Head"] = "thead";
+    TableNode["Body"] = "tbody";
+    TableNode["Row"] = "tr";
+    TableNode["HeaderCell"] = "th";
+    TableNode["DataCell"] = "td";
+})(TableNode = exports.TableNode || (exports.TableNode = {}));
+var TableAttrs;
+(function (TableAttrs) {
+    TableAttrs["CellAlign"] = "cell-align";
+})(TableAttrs = exports.TableAttrs || (exports.TableAttrs = {}));
+var CellAlign;
+(function (CellAlign) {
+    CellAlign["Left"] = "left";
+    CellAlign["Center"] = "center";
+    CellAlign["Right"] = "right";
+})(CellAlign = exports.CellAlign || (exports.CellAlign = {}));

package/build/cjs/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/cjs/extensions/markdown/Table/TableSpecs/index.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TableSpecs = exports.TableNode = void 0;
+const const_1 = require("./const");
+const parser_1 = require("./parser");
+const schema_1 = require("./schema");
+const serializer_1 = require("./serializer");
+var const_2 = require("./const");
+Object.defineProperty(exports, "TableNode", { enumerable: true, get: function () { return const_2.TableNode; } });
+const TableSpecs = (builder) => {
+    builder
+        .addNode(const_1.TableNode.Table, () => ({
+        spec: schema_1.schemaSpecs[const_1.TableNode.Table],
+        toMd: serializer_1.serializerTokens[const_1.TableNode.Table],
+        fromMd: { tokenSpec: parser_1.parserTokens[const_1.TableNode.Table] },
+    }))
+        .addNode(const_1.TableNode.Head, () => ({
+        spec: schema_1.schemaSpecs[const_1.TableNode.Head],
+        toMd: serializer_1.serializerTokens[const_1.TableNode.Head],
+        fromMd: { tokenSpec: parser_1.parserTokens[const_1.TableNode.Head] },
+    }))
+        .addNode(const_1.TableNode.Body, () => ({
+        spec: schema_1.schemaSpecs[const_1.TableNode.Body],
+        toMd: serializer_1.serializerTokens[const_1.TableNode.Body],
+        fromMd: { tokenSpec: parser_1.parserTokens[const_1.TableNode.Body] },
+    }))
+        .addNode(const_1.TableNode.Row, () => ({
+        spec: schema_1.schemaSpecs[const_1.TableNode.Row],
+        toMd: serializer_1.serializerTokens[const_1.TableNode.Row],
+        fromMd: { tokenSpec: parser_1.parserTokens[const_1.TableNode.Row] },
+    }))
+        .addNode(const_1.TableNode.HeaderCell, () => ({
+        spec: schema_1.schemaSpecs[const_1.TableNode.HeaderCell],
+        toMd: serializer_1.serializerTokens[const_1.TableNode.HeaderCell],
+        fromMd: { tokenSpec: parser_1.parserTokens[const_1.TableNode.HeaderCell] },
+    }))
+        .addNode(const_1.TableNode.DataCell, () => ({
+        spec: schema_1.schemaSpecs[const_1.TableNode.DataCell],
+        toMd: serializer_1.serializerTokens[const_1.TableNode.DataCell],
+        fromMd: { tokenSpec: parser_1.parserTokens[const_1.TableNode.DataCell] },
+    }));
+};
+exports.TableSpecs = TableSpecs;

package/build/cjs/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/cjs/extensions/markdown/Table/TableSpecs/parser.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parserTokens = void 0;
+const const_1 = require("../const");
+exports.parserTokens = {
+    [const_1.TableNode.Table]: { name: const_1.TableNode.Table, type: 'block' },
+    [const_1.TableNode.Head]: { name: const_1.TableNode.Head, type: 'block' },
+    [const_1.TableNode.Body]: { name: const_1.TableNode.Body, type: 'block' },
+    [const_1.TableNode.Row]: { name: const_1.TableNode.Row, type: 'block' },
+    [const_1.TableNode.HeaderCell]: {
+        name: const_1.TableNode.HeaderCell,
+        type: 'block',
+        getAttrs: getTableCellAttrs,
+    },
+    [const_1.TableNode.DataCell]: { name: const_1.TableNode.DataCell, type: 'block', getAttrs: getTableCellAttrs },
+};
+function getTableCellAttrs({ attrs }) {
+    const objAttrs = Object.fromEntries(attrs || []);
+    let align = const_1.CellAlign.Left;
+    if (objAttrs.style) {
+        const styles = objAttrs.style.split(';');
+        const textAlignStyle = styles.find((str) => str.startsWith('text-align:')) || '';
+        [, align = const_1.CellAlign.Left] = textAlignStyle.split(':');
+    }
+    return { [const_1.TableAttrs.CellAlign]: align };
+}

package/build/cjs/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/cjs/extensions/markdown/Table/TableSpecs/schema.js

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

package/build/cjs/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/cjs/extensions/markdown/Table/TableSpecs/serializer.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serializerTokens = void 0;
+const const_1 = require("../const");
+exports.serializerTokens = {
+    [const_1.TableNode.Table]: (state, node) => {
+        state.ensureNewLine();
+        state.write('\n');
+        state.setNoAutoBlank();
+        state.renderContent(node);
+        state.unsetNoAutoBlank();
+        state.ensureNewLine();
+        state.closeBlock(node);
+    },
+    [const_1.TableNode.Head]: (state, node) => {
+        state.renderContent(node);
+        // @ts-expect-error
+        for (const cellNode of node.content.content[0].content.content) {
+            switch (cellNode.attrs[const_1.TableAttrs.CellAlign]) {
+                case const_1.CellAlign.Left:
+                    state.write('|:---');
+                    break;
+                case const_1.CellAlign.Center:
+                    state.write('|:---:');
+                    break;
+                case const_1.CellAlign.Right:
+                    state.write('|---:');
+                    break;
+                default:
+                    state.write('|---');
+                    break;
+            }
+        }
+        state.write('|');
+        state.ensureNewLine();
+        state.closeBlock(node);
+    },
+    [const_1.TableNode.Body]: (state, node) => {
+        state.renderContent(node);
+        state.closeBlock(node);
+    },
+    [const_1.TableNode.Row]: (state, node) => {
+        state.renderContent(node);
+        state.closeBlock(node);
+        state.write('|');
+        state.ensureNewLine();
+    },
+    [const_1.TableNode.HeaderCell]: (state, node) => {
+        state.write('|');
+        state.renderInline(node);
+        state.closeBlock(node);
+    },
+    [const_1.TableNode.DataCell]: (state, node) => {
+        state.write('|');
+        state.renderInline(node);
+        state.closeBlock(node);
+    },
+};

package/build/cjs/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/cjs/extensions/markdown/Table/actions/cellAlign.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setCellRightAlign = exports.setCellCenterAlign = exports.setCellLeftAlign = void 0;
+const const_1 = require("../TableSpecs/const");
+const helpers_1 = require("../helpers");
+function factory(align) {
+    return {
+        isActive(state) {
+            const cell = (0, helpers_1.findParentCell)(state);
+            return (cell === null || cell === void 0 ? void 0 : cell.node.attrs[const_1.TableAttrs.CellAlign]) === align;
+        },
+        isEnable(state) {
+            return (0, helpers_1.isIntoTable)(state);
+        },
+        run(state, dispatch) {
+            const table = (0, helpers_1.findParentTable)(state);
+            const row = (0, helpers_1.findParentRow)(state);
+            const cell = (0, helpers_1.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 = (0, helpers_1.findTableRows)(table.node, state.schema);
+            for (const row of allRows) {
+                const rowCells = (0, helpers_1.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), { [const_1.TableAttrs.CellAlign]: align }));
+            }
+            dispatch(tr);
+        },
+    };
+}
+exports.setCellLeftAlign = factory(const_1.CellAlign.Left);
+exports.setCellCenterAlign = factory(const_1.CellAlign.Center);
+exports.setCellRightAlign = factory(const_1.CellAlign.Right);

package/build/cjs/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/cjs/extensions/markdown/Table/actions/innerActions.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.innerActions = void 0;
+const table_utils_1 = require("../../../../table-utils");
+const actions_1 = require("../../../../utils/actions");
+const helpers_1 = require("../helpers");
+const cellAlign_1 = require("./cellAlign");
+const addRowAfter = (state, dispatch, view) => {
+    if (!(0, helpers_1.findParentBody)(state)) {
+        return false; // TODO: process when cursor is inside thead
+    }
+    return (0, table_utils_1.addRowAfter)(state, dispatch, view);
+};
+const addRow = {
+    isEnable: addRowAfter,
+    run: addRowAfter,
+};
+const deleteRow = {
+    isEnable: table_utils_1.removeCurrentRow,
+    run: table_utils_1.removeCurrentRow,
+};
+const addColumn = {
+    isEnable: table_utils_1.addColumnAfter,
+    run: table_utils_1.addColumnAfter,
+};
+const deleteColumn = {
+    isEnable: table_utils_1.removeCurrentColumn,
+    run: table_utils_1.removeCurrentColumn,
+};
+exports.innerActions = (0, actions_1.defineActions)({
+    setCellLeftAlign: cellAlign_1.setCellLeftAlign,
+    setCellCenterAlign: cellAlign_1.setCellCenterAlign,
+    setCellRightAlign: cellAlign_1.setCellRightAlign,
+    addRow,
+    deleteRow,
+    addColumn,
+    deleteColumn,
+});

package/build/cjs/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;

package/build/cjs/extensions/markdown/Table/actions/tableActions.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteTableAction = exports.createTableAction = void 0;
+const prosemirror_utils_1 = require("prosemirror-utils");
+const const_1 = require("../const");
+const helpers_1 = require("../helpers");
+const mdTamplate = `
+
+| Heading | Heading |
+| ------- | ------- |
+| Text    | Text    |
+| Text    | Text    |
+
+`.trim();
+const createTableFactory = (parser) => (state, dispatch) => {
+    if ((0, helpers_1.isIntoTable)(state)) {
+        return false;
+    }
+    if (dispatch) {
+        const node = parser.parse(mdTamplate);
+        dispatch(state.tr.replaceSelectionWith(node).scrollIntoView());
+    }
+    return true;
+};
+const removeTable = (state, dispatch) => {
+    if ((0, helpers_1.isIntoTable)(state)) {
+        dispatch === null || dispatch === void 0 ? void 0 : dispatch((0, prosemirror_utils_1.removeParentNodeOfType)(state.schema.nodes[const_1.TableNode.Table])(state.tr));
+        return true;
+    }
+    return false;
+};
+const createTableAction = ({ markupParser }) => ({
+    isActive: helpers_1.isIntoTable,
+    isEnable: createTableFactory(markupParser),
+    run: createTableFactory(markupParser),
+});
+exports.createTableAction = createTableAction;
+exports.deleteTableAction = {
+    isEnable: removeTable,
+    run: removeTable,
+};

package/build/cjs/extensions/markdown/Table/const.d.ts

@@ -0,0 +1 @@
+export * from './TableSpecs/const';

package/build/cjs/extensions/markdown/Table/const.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./TableSpecs/const"), exports);

package/build/cjs/extensions/markdown/Table/helpers.d.ts

@@ -0,0 +1,15 @@
+import { Node, Schema } from 'prosemirror-model';
+import { EditorState } from 'prosemirror-state';
+export declare const isIntoTable: (state: EditorState) => boolean;
+export declare const findParentTable: (state: EditorState) => import("prosemirror-utils/dist/types").FindResult;
+export declare const findParentBody: (state: EditorState) => import("prosemirror-utils/dist/types").FindResult;
+export declare const findParentRow: (state: EditorState) => import("prosemirror-utils/dist/types").FindResult;
+export declare const findParentCell: (state: EditorState) => import("prosemirror-utils/dist/types").FindResult;
+export declare const findTableRows: (table: Node, schema: Schema) => {
+    node: Node;
+    pos: number;
+}[];
+export declare const findTableCells: (table: Node, schema: Schema) => {
+    node: Node;
+    pos: number;
+}[];