@gravity-ui/markdown-editor 13.0.0

package/build/cjs/extensions/behavior/utils/upload.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FilesBatchUploadProcess = void 0;
+const upload_1 = require("../../../utils/upload");
+class FilesBatchUploadProcess {
+    constructor(view, files, uploadHandler) {
+        this.view = view;
+        this.files = files;
+        this.uploadHandler = uploadHandler;
+    }
+    async run() {
+        await this.insertSkeleton();
+        await this.batchUpload();
+        this.removeSkeleton();
+    }
+    async insertSkeleton() {
+        const { view } = this;
+        const { state } = view;
+        this.skeletonDescriptor = await this.createSkeleton();
+        let tr = state.tr;
+        if (!state.selection.empty)
+            tr = tr.deleteSelection();
+        tr = this.skeletonDescriptor.applyTo(tr);
+        view.dispatch(tr);
+    }
+    async batchUpload() {
+        const insertQueue = [];
+        await (0, upload_1.batchUploadFiles)(this.files, this.uploadHandler, (res) => {
+            insertQueue.push((async () => {
+                const node = await this.createPMNode(res);
+                const { view } = this;
+                const { schema } = view.state;
+                view.dispatch(view.state.tr.insert(this.skeletonDescriptor.pos, [
+                    schema.text(' '),
+                    node,
+                    schema.text(' '),
+                ]));
+            })().catch(console.error));
+        });
+        await Promise.allSettled(insertQueue);
+    }
+    removeSkeleton() {
+        const { view } = this;
+        view.dispatch(this.skeletonDescriptor.rmDeco(view.state.tr));
+    }
+}
+exports.FilesBatchUploadProcess = FilesBatchUploadProcess;

package/build/cjs/extensions/index.d.ts

@@ -0,0 +1,4 @@
+export * from './base';
+export * from './behavior';
+export * from './markdown';
+export * from './yfm';

package/build/cjs/extensions/index.js

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

package/build/cjs/extensions/markdown/Blockquote/BlockquoteSpecs/index.d.ts

@@ -0,0 +1,6 @@
+import type { Node } from 'prosemirror-model';
+import type { ExtensionAuto } from '../../../../core';
+export declare const blockquoteNodeName = "blockquote";
+export declare const blockquoteType: (schema: import("prosemirror-model").Schema<any, any>) => import("prosemirror-model").NodeType;
+export declare const isBlockqouteNode: (node: Node) => boolean;
+export declare const BlockquoteSpecs: ExtensionAuto;

package/build/cjs/extensions/markdown/Blockquote/BlockquoteSpecs/index.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BlockquoteSpecs = exports.isBlockqouteNode = exports.blockquoteType = exports.blockquoteNodeName = void 0;
+const schema_1 = require("../../../../utils/schema");
+exports.blockquoteNodeName = 'blockquote';
+exports.blockquoteType = (0, schema_1.nodeTypeFactory)(exports.blockquoteNodeName);
+const isBlockqouteNode = (node) => node.type.name === exports.blockquoteNodeName;
+exports.isBlockqouteNode = isBlockqouteNode;
+const BlockquoteSpecs = (builder) => {
+    builder.addNode(exports.blockquoteNodeName, () => ({
+        spec: {
+            content: 'block+',
+            group: 'block',
+            defining: true,
+            parseDOM: [{ tag: 'blockquote' }],
+            toDOM() {
+                return ['blockquote', 0];
+            },
+        },
+        fromMd: { tokenSpec: { name: exports.blockquoteNodeName, type: 'block' } },
+        toMd: (state, node) => {
+            state.wrapBlock('> ', null, node, () => state.renderContent(node));
+        },
+    }));
+};
+exports.BlockquoteSpecs = BlockquoteSpecs;

package/build/cjs/extensions/markdown/Blockquote/commands.d.ts

@@ -0,0 +1,5 @@
+import type { Command } from 'prosemirror-state';
+import '../../../types/spec';
+export declare const liftFromQuote: Command;
+export declare const joinPrevQuote: Command;
+export declare const toggleQuote: Command;

package/build/cjs/extensions/markdown/Blockquote/commands.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toggleQuote = exports.joinPrevQuote = exports.liftFromQuote = void 0;
+const prosemirror_commands_1 = require("prosemirror-commands");
+const join_1 = require("../../../commands/join");
+require("../../../types/spec");
+const selection_1 = require("../../../utils/selection");
+const const_1 = require("./const");
+const liftFromQuote = (state, dispatch) => {
+    const $cursor = (0, selection_1.get$CursorAtBlockStart)(state.selection);
+    if (!$cursor || !(0, const_1.isBlockqouteNode)($cursor.node(-1)))
+        return false;
+    return (0, prosemirror_commands_1.lift)(state, dispatch);
+};
+exports.liftFromQuote = liftFromQuote;
+exports.joinPrevQuote = (0, join_1.joinPreviousBlock)({
+    checkPrevNode: const_1.isBlockqouteNode,
+    skipNode: const_1.isBlockqouteNode,
+});
+const toggleQuote = (state, dispatch) => {
+    const { selection } = state;
+    const qType = (0, const_1.bqType)(state.schema);
+    if (!(0, selection_1.isTextSelection)(selection) || !selection.$cursor)
+        return (0, prosemirror_commands_1.wrapIn)(qType)(state, dispatch);
+    const { $cursor } = selection;
+    let { depth } = $cursor;
+    while (depth > 0) {
+        const node = $cursor.node(depth);
+        const nodeSpec = node.type.spec;
+        if (!nodeSpec.complex || nodeSpec.complex === 'root') {
+            const targetDepth = depth - 1;
+            const range = getBlockRange($cursor, depth);
+            if ((0, const_1.isBlockqouteNode)($cursor.node(targetDepth))) {
+                dispatch === null || dispatch === void 0 ? void 0 : dispatch(state.tr.lift(range, targetDepth - 1).scrollIntoView());
+            }
+            else {
+                dispatch === null || dispatch === void 0 ? void 0 : dispatch(state.tr.wrap(range, [{ type: qType }]).scrollIntoView());
+            }
+            return true;
+        }
+        depth--;
+    }
+    return false;
+};
+exports.toggleQuote = toggleQuote;
+function getBlockRange($pos, depth) {
+    const { doc } = $pos;
+    const $before = doc.resolve($pos.before(depth));
+    const $after = doc.resolve($pos.after(depth));
+    return $before.blockRange($after);
+}

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

@@ -0,0 +1,5 @@
+export { blockquoteNodeName, blockquoteType, isBlockqouteNode } from './BlockquoteSpecs';
+/** @deprecated Use `blockquoteNodeName` instead */
+export declare const blockquote = "blockquote";
+/** @deprecated Use `blockquoteType` instead */
+export declare const bqType: (schema: import("prosemirror-model").Schema<any, any>) => import("prosemirror-model").NodeType;

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

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bqType = exports.blockquote = exports.isBlockqouteNode = exports.blockquoteType = exports.blockquoteNodeName = void 0;
+const BlockquoteSpecs_1 = require("./BlockquoteSpecs");
+var BlockquoteSpecs_2 = require("./BlockquoteSpecs");
+Object.defineProperty(exports, "blockquoteNodeName", { enumerable: true, get: function () { return BlockquoteSpecs_2.blockquoteNodeName; } });
+Object.defineProperty(exports, "blockquoteType", { enumerable: true, get: function () { return BlockquoteSpecs_2.blockquoteType; } });
+Object.defineProperty(exports, "isBlockqouteNode", { enumerable: true, get: function () { return BlockquoteSpecs_2.isBlockqouteNode; } });
+/** @deprecated Use `blockquoteNodeName` instead */
+exports.blockquote = BlockquoteSpecs_1.blockquoteNodeName;
+/** @deprecated Use `blockquoteType` instead */
+exports.bqType = BlockquoteSpecs_1.blockquoteType;

package/build/cjs/extensions/markdown/Blockquote/index.d.ts

@@ -0,0 +1,14 @@
+import type { Action, ExtensionAuto } from '../../../core';
+export { blockquote, blockquoteNodeName, blockquoteType } from './const';
+declare const bqAction = "quote";
+export declare type BlockquoteOptions = {
+    qouteKey?: string | null;
+};
+export declare const Blockquote: ExtensionAuto<BlockquoteOptions>;
+declare global {
+    namespace WysiwygEditor {
+        interface Actions {
+            [bqAction]: Action;
+        }
+    }
+}

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

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Blockquote = exports.blockquoteType = exports.blockquoteNodeName = exports.blockquote = void 0;
+const prosemirror_commands_1 = require("prosemirror-commands");
+const prosemirror_utils_1 = require("prosemirror-utils");
+const inputrules_1 = require("../../../utils/inputrules");
+const keymap_1 = require("../../../utils/keymap");
+const BlockquoteSpecs_1 = require("./BlockquoteSpecs");
+const commands_1 = require("./commands");
+var const_1 = require("./const");
+Object.defineProperty(exports, "blockquote", { enumerable: true, get: function () { return const_1.blockquote; } });
+Object.defineProperty(exports, "blockquoteNodeName", { enumerable: true, get: function () { return const_1.blockquoteNodeName; } });
+Object.defineProperty(exports, "blockquoteType", { enumerable: true, get: function () { return const_1.blockquoteType; } });
+const bqAction = 'quote';
+const Blockquote = (builder, opts) => {
+    builder.use(BlockquoteSpecs_1.BlockquoteSpecs);
+    if (opts === null || opts === void 0 ? void 0 : opts.qouteKey) {
+        const { qouteKey } = opts;
+        builder.addKeymap(({ schema }) => ({
+            [qouteKey]: (0, keymap_1.withLogAction)('blockquote', (0, prosemirror_commands_1.wrapIn)((0, BlockquoteSpecs_1.blockquoteType)(schema))),
+        }));
+    }
+    builder.addKeymap(() => ({
+        Backspace: (0, prosemirror_commands_1.chainCommands)(commands_1.liftFromQuote, commands_1.joinPrevQuote),
+    }));
+    builder.addInputRules(({ schema }) => ({ rules: [blockQuoteRule((0, BlockquoteSpecs_1.blockquoteType)(schema))] }));
+    builder.addAction(bqAction, ({ schema }) => {
+        const bq = (0, BlockquoteSpecs_1.blockquoteType)(schema);
+        return {
+            isActive: (state) => (0, prosemirror_utils_1.hasParentNodeOfType)(bq)(state.selection),
+            isEnable: commands_1.toggleQuote,
+            run: commands_1.toggleQuote,
+        };
+    });
+};
+exports.Blockquote = Blockquote;
+/**
+ * Given a blockquote node type, returns an input rule that turns `"> "`
+ * at the start of a textblock into a blockquote.
+ */
+function blockQuoteRule(nodeType) {
+    return (0, inputrules_1.wrappingInputRule)(/^\s*>\s$/, nodeType);
+}

package/build/cjs/extensions/markdown/Bold/BoldSpecs/index.d.ts

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

package/build/cjs/extensions/markdown/Bold/BoldSpecs/index.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BoldSpecs = exports.boldType = exports.boldMarkName = void 0;
+const schema_1 = require("../../../../utils/schema");
+exports.boldMarkName = 'strong';
+exports.boldType = (0, schema_1.markTypeFactory)(exports.boldMarkName);
+const BoldSpecs = (builder) => {
+    builder.addMark(exports.boldMarkName, () => ({
+        spec: {
+            parseDOM: [
+                { tag: 'b' },
+                { tag: 'strong' },
+                {
+                    style: 'font-weight',
+                    getAttrs: (value) => /^(bold(er)?|[5-9]\d{2,})$/.test(value) && null,
+                },
+            ],
+            toDOM() {
+                return ['strong'];
+            },
+        },
+        fromMd: {
+            tokenSpec: {
+                name: exports.boldMarkName,
+                type: 'mark',
+            },
+        },
+        toMd: { open: '**', close: '**', mixable: true, expelEnclosingWhitespace: true },
+    }));
+};
+exports.BoldSpecs = BoldSpecs;

package/build/cjs/extensions/markdown/Bold/index.d.ts

@@ -0,0 +1,16 @@
+import type { Action, ExtensionAuto } from '../../../core';
+export { boldMarkName, boldType } from './BoldSpecs';
+/** @deprecated Use `boldMarkName` instead */
+export declare const bold = "strong";
+declare const bAction = "bold";
+export declare type BoldOptions = {
+    boldKey?: string | null;
+};
+export declare const Bold: ExtensionAuto<BoldOptions>;
+declare global {
+    namespace WysiwygEditor {
+        interface Actions {
+            [bAction]: Action;
+        }
+    }
+}

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

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Bold = exports.bold = exports.boldType = exports.boldMarkName = 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 BoldSpecs_1 = require("./BoldSpecs");
+var BoldSpecs_2 = require("./BoldSpecs");
+Object.defineProperty(exports, "boldMarkName", { enumerable: true, get: function () { return BoldSpecs_2.boldMarkName; } });
+Object.defineProperty(exports, "boldType", { enumerable: true, get: function () { return BoldSpecs_2.boldType; } });
+/** @deprecated Use `boldMarkName` instead */
+exports.bold = BoldSpecs_1.boldMarkName;
+const bAction = 'bold';
+const Bold = (builder, opts) => {
+    builder.use(BoldSpecs_1.BoldSpecs);
+    builder.addAction(bAction, ({ schema }) => (0, actions_1.createToggleMarkAction)((0, BoldSpecs_1.boldType)(schema)));
+    if (opts === null || opts === void 0 ? void 0 : opts.boldKey) {
+        const { boldKey } = opts;
+        builder.addKeymap(({ schema }) => ({
+            [boldKey]: (0, keymap_1.withLogAction)('bold', (0, prosemirror_commands_1.toggleMark)((0, BoldSpecs_1.boldType)(schema))),
+        }));
+    }
+    builder.addInputRules(({ schema }) => ({
+        rules: [
+            (0, inputrules_1.markInputRule)({ open: '**', close: '**', ignoreBetween: '*' }, (0, BoldSpecs_1.boldType)(schema)),
+            (0, inputrules_1.markInputRule)({ open: '__', close: '__', ignoreBetween: '_' }, (0, BoldSpecs_1.boldType)(schema)),
+        ],
+    }));
+};
+exports.Bold = Bold;

package/build/cjs/extensions/markdown/Breaks/BreaksSpecs/index.d.ts

@@ -0,0 +1,14 @@
+import type { ExtensionAuto } from '../../../../core';
+export declare enum BreakNodeName {
+    HardBreak = "hard_break",
+    SoftBreak = "soft_break"
+}
+export declare const hbType: (schema: import("prosemirror-model").Schema<any, any>) => import("prosemirror-model").NodeType;
+export declare const sbType: (schema: import("prosemirror-model").Schema<any, any>) => import("prosemirror-model").NodeType;
+export declare type BreaksSpecsOptions = {
+    /**
+     * @default 'hard'
+     */
+    preferredBreak?: 'hard' | 'soft';
+};
+export declare const BreaksSpecs: ExtensionAuto<BreaksSpecsOptions>;

package/build/cjs/extensions/markdown/Breaks/BreaksSpecs/index.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BreaksSpecs = exports.sbType = exports.hbType = exports.BreakNodeName = void 0;
+const schema_1 = require("../../../../utils/schema");
+var BreakNodeName;
+(function (BreakNodeName) {
+    BreakNodeName["HardBreak"] = "hard_break";
+    BreakNodeName["SoftBreak"] = "soft_break";
+})(BreakNodeName = exports.BreakNodeName || (exports.BreakNodeName = {}));
+exports.hbType = (0, schema_1.nodeTypeFactory)(BreakNodeName.HardBreak);
+exports.sbType = (0, schema_1.nodeTypeFactory)(BreakNodeName.SoftBreak);
+const BreaksSpecs = (builder, opts) => {
+    const { preferredBreak = 'hard' } = opts;
+    const parseDOM = [{ tag: 'br' }];
+    builder.addNode(BreakNodeName.HardBreak, () => ({
+        spec: {
+            inline: true,
+            group: 'inline break',
+            marks: '',
+            isBreak: true,
+            selectable: false,
+            parseDOM: preferredBreak === 'hard' ? parseDOM : undefined,
+            toDOM() {
+                return ['br'];
+            },
+        },
+        fromMd: { tokenName: 'hardbreak', tokenSpec: { name: BreakNodeName.HardBreak, type: 'node' } },
+        toMd: (state, node, parent, index) => {
+            for (let i = index + 1; i < parent.childCount; i++) {
+                if (parent.child(i).type !== node.type) {
+                    state.write('\\\n');
+                    return;
+                }
+            }
+        },
+    }));
+    // TODO: should we handle softbreak differently at different md.options.breaks setting?
+    // we can safely convert softbreak into hardbreak,
+    // but in this case non-edited markup will always be changed – a backspash will be added
+    builder.addNode(BreakNodeName.SoftBreak, () => ({
+        spec: {
+            inline: true,
+            group: 'inline break',
+            marks: '',
+            isBreak: true,
+            selectable: false,
+            parseDOM: preferredBreak === 'soft' ? parseDOM : undefined,
+            toDOM() {
+                return ['br'];
+            },
+        },
+        fromMd: { tokenName: 'softbreak', tokenSpec: { name: BreakNodeName.SoftBreak, type: 'node' } },
+        toMd: (state, node, parent, index) => {
+            for (let i = index + 1; i < parent.childCount; i++) {
+                if (parent.child(i).type !== node.type) {
+                    state.write('\n');
+                    return;
+                }
+            }
+        },
+    }));
+};
+exports.BreaksSpecs = BreaksSpecs;

package/build/cjs/extensions/markdown/Breaks/index.d.ts

@@ -0,0 +1,20 @@
+import type { ExtensionAuto } from '../../../core';
+export { BreaksSpecs, BreakNodeName, hbType, sbType } from './BreaksSpecs';
+export declare type BreaksOptions = {
+    /**
+     * This option is used if the 'breaks' parameter is not specified via the context
+     * @default 'hard'
+     */
+    preferredBreak?: 'hard' | 'soft';
+};
+export declare const Breaks: ExtensionAuto<BreaksOptions>;
+declare global {
+    namespace WysiwygEditor {
+        interface Context {
+            /**
+             * Same as @type {MarkdownIt.Options.breaks}
+             */
+            breaks: boolean;
+        }
+    }
+}

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

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Breaks = exports.sbType = exports.hbType = exports.BreakNodeName = exports.BreaksSpecs = void 0;
+const prosemirror_commands_1 = require("prosemirror-commands");
+const prosemirror_state_1 = require("prosemirror-state");
+const logger_1 = require("../../../logger");
+const platform_1 = require("../../../utils/platform");
+const selection_1 = require("../../../utils/selection");
+const BaseSchemaSpecs_1 = require("../../base/BaseSchema/BaseSchemaSpecs");
+const BreaksSpecs_1 = require("./BreaksSpecs");
+var BreaksSpecs_2 = require("./BreaksSpecs");
+Object.defineProperty(exports, "BreaksSpecs", { enumerable: true, get: function () { return BreaksSpecs_2.BreaksSpecs; } });
+Object.defineProperty(exports, "BreakNodeName", { enumerable: true, get: function () { return BreaksSpecs_2.BreakNodeName; } });
+Object.defineProperty(exports, "hbType", { enumerable: true, get: function () { return BreaksSpecs_2.hbType; } });
+Object.defineProperty(exports, "sbType", { enumerable: true, get: function () { return BreaksSpecs_2.sbType; } });
+const Breaks = (builder, opts) => {
+    var _a;
+    let preferredBreak;
+    if (builder.context.has('breaks')) {
+        preferredBreak = builder.context.get('breaks') ? 'soft' : 'hard';
+    }
+    else {
+        preferredBreak = (_a = opts.preferredBreak) !== null && _a !== void 0 ? _a : 'hard';
+        logger_1.logger.info("[Breaks extension]: Parameter 'breaks' is not defined in context; value from options is used");
+    }
+    builder.use(BreaksSpecs_1.BreaksSpecs, { preferredBreak });
+    builder.addKeymap(({ schema }) => {
+        const cmd = addBr((preferredBreak === 'soft' ? BreaksSpecs_1.sbType : BreaksSpecs_1.hbType)(schema));
+        const keys = {
+            'Shift-Enter': cmd,
+        };
+        if ((0, platform_1.isMac)()) {
+            keys['Ctrl-Enter'] = cmd;
+        }
+        return keys;
+    });
+};
+exports.Breaks = Breaks;
+const addBr = (br) => (0, prosemirror_commands_1.chainCommands)(prosemirror_commands_1.exitCode, (state, dispatch) => {
+    var _a;
+    const { selection: sel, schema } = state;
+    if (!(0, selection_1.isTextSelection)(sel) ||
+        !sel.empty ||
+        // breaks can only be in the paragraph
+        ((_a = sel.$cursor) === null || _a === void 0 ? void 0 : _a.parent.type) !== (0, BaseSchemaSpecs_1.pType)(schema))
+        return false;
+    if (isBreakNode(sel.$cursor.nodeBefore)) {
+        if (dispatch) {
+            const { $cursor, $cursor: { pos }, } = sel;
+            const from = isBreakNode($cursor.nodeAfter) ? pos + 1 : pos;
+            const posEnd = $cursor.end();
+            const posAfter = $cursor.after();
+            const contentAfter = state.doc.slice(from, posEnd, false).content;
+            let tr = state.tr.insert(posAfter, (0, BaseSchemaSpecs_1.pType)(schema).create(null, contentAfter));
+            tr = tr
+                .setSelection(prosemirror_state_1.TextSelection.create(tr.doc, posAfter + 1))
+                .scrollIntoView()
+                .delete(pos, posEnd) // remove content after current pos (it's moved to next para)
+                .delete(pos - 1, pos); // remove break before current pos ($cursor.nodeBefore)
+            dispatch(tr);
+        }
+        return true;
+    }
+    dispatch === null || dispatch === void 0 ? void 0 : dispatch(state.tr.replaceSelectionWith(br.create()).scrollIntoView());
+    return true;
+});
+function isBreakNode(node) {
+    return Boolean(node === null || node === void 0 ? void 0 : node.type.spec.isBreak);
+}

package/build/cjs/extensions/markdown/Code/CodeSpecs/index.d.ts

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

package/build/cjs/extensions/markdown/Code/CodeSpecs/index.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CodeSpecs = exports.codeType = exports.codeMarkName = void 0;
+const schema_1 = require("../../../../utils/schema");
+exports.codeMarkName = 'code';
+exports.codeType = (0, schema_1.markTypeFactory)(exports.codeMarkName);
+const CodeSpecs = (builder) => {
+    builder.addMark(exports.codeMarkName, () => ({
+        spec: {
+            code: true,
+            parseDOM: [{ tag: 'code' }],
+            toDOM() {
+                return ['code'];
+            },
+        },
+        toMd: {
+            open(_state, _mark, parent, index) {
+                return backticksFor(parent.child(index), -1);
+            },
+            close(_state, _mark, parent, index) {
+                return backticksFor(parent.child(index - 1), 1);
+            },
+            escape: false,
+        },
+        fromMd: {
+            tokenSpec: { name: exports.codeMarkName, type: 'mark', code: true, noCloseToken: true },
+            tokenName: 'code_inline',
+        },
+    }), builder.Priority.Lowest);
+};
+exports.CodeSpecs = CodeSpecs;
+function backticksFor(node, side) {
+    const ticks = /`+/g;
+    let m;
+    let len = 0;
+    if (node.isText)
+        while ((m = ticks.exec(node.text || '')))
+            len = Math.max(len, m[0].length);
+    let result = len > 0 && side > 0 ? ' `' : '`';
+    for (let i = 0; i < len; i++)
+        result += '`';
+    if (len > 0 && side < 0)
+        result += ' ';
+    return result;
+}

package/build/cjs/extensions/markdown/Code/code.css

@@ -0,0 +1,24 @@
+@keyframes code_fake_blink {
+  49% {
+    border-color: unset;
+  }
+  50% {
+    border-color: transparent;
+  }
+  99% {
+    border-color: transparent;
+  }
+}
+.ProseMirror.no-cursor {
+  caret-color: transparent;
+}
+
+.ProseMirror-focused .fake-cursor {
+  position: relative;
+  z-index: 1;
+  margin-right: -1px;
+  border-left-width: 1px;
+  border-left-style: solid;
+  animation: code_fake_blink 1s;
+  animation-iteration-count: infinite;
+}

package/build/cjs/extensions/markdown/Code/index.d.ts

@@ -0,0 +1,16 @@
+import type { Action, ExtensionAuto } from '../../../core';
+export { codeMarkName, codeType } from './CodeSpecs';
+/** @deprecated Use `codeMarkName` instead */
+export declare const code = "code";
+declare const codeAction = "code";
+export declare type CodeOptions = {
+    codeKey?: string | null;
+};
+export declare const Code: ExtensionAuto<CodeOptions>;
+declare global {
+    namespace WysiwygEditor {
+        interface Actions {
+            [codeAction]: Action;
+        }
+    }
+}

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

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Code = exports.code = exports.codeType = exports.codeMarkName = void 0;
+const tslib_1 = require("tslib");
+const prosemirror_codemark_1 = tslib_1.__importDefault(require("prosemirror-codemark"));
+const prosemirror_commands_1 = require("prosemirror-commands");
+const prosemirror_state_1 = require("prosemirror-state");
+const actions_1 = require("../../../utils/actions");
+const keymap_1 = require("../../../utils/keymap");
+const CodeSpecs_1 = require("./CodeSpecs");
+var CodeSpecs_2 = require("./CodeSpecs");
+Object.defineProperty(exports, "codeMarkName", { enumerable: true, get: function () { return CodeSpecs_2.codeMarkName; } });
+Object.defineProperty(exports, "codeType", { enumerable: true, get: function () { return CodeSpecs_2.codeType; } });
+/** @deprecated Use `codeMarkName` instead */
+exports.code = CodeSpecs_1.codeMarkName;
+const codeAction = 'code';
+const Code = (builder, opts) => {
+    builder.use(CodeSpecs_1.CodeSpecs);
+    builder.addAction(codeAction, ({ schema }) => (0, actions_1.createToggleMarkAction)((0, CodeSpecs_1.codeType)(schema)));
+    if (opts === null || opts === void 0 ? void 0 : opts.codeKey) {
+        const { codeKey } = opts;
+        builder.addKeymap(({ schema }) => ({
+            [codeKey]: (0, keymap_1.withLogAction)('code_inline', (0, prosemirror_commands_1.toggleMark)((0, CodeSpecs_1.codeType)(schema))),
+        }));
+    }
+    builder
+        // codemark adds inputRule for `code`,
+        // adds fake cursor behaviour when crossing inline_code boundaries,
+        // wrap current selected text to inline_code when '`' was pressed.
+        // See demo: https://curvenote.github.io/prosemirror-codemark/
+        .addPlugin(({ schema }) => (0, prosemirror_codemark_1.default)({ markType: (0, CodeSpecs_1.codeType)(schema) }));
+    builder.addPlugin(() => 
+    // apply codemark when typing text between ``
+    new prosemirror_state_1.Plugin({
+        props: {
+            handleTextInput: (view, from, to, text) => {
+                var _a, _b, _c, _d;
+                const { selection: { $anchor }, tr, schema, } = view.state;
+                if (((_b = (_a = $anchor.nodeBefore) === null || _a === void 0 ? void 0 : _a.text) === null || _b === void 0 ? void 0 : _b.endsWith('`')) &&
+                    ((_d = (_c = $anchor.nodeAfter) === null || _c === void 0 ? void 0 : _c.text) === null || _d === void 0 ? void 0 : _d.startsWith('`'))) {
+                    view.dispatch(tr.replaceRangeWith(from - 1, to + 1, view.state.schema.text(text, [(0, CodeSpecs_1.codeType)(schema).create()])));
+                    return true;
+                }
+                return false;
+            },
+        },
+    }));
+};
+exports.Code = Code;

package/build/cjs/extensions/markdown/CodeBlock/CodeBlockHighlight/CodeBlockHighlight.d.ts

@@ -0,0 +1,7 @@
+import type { Options } from '@diplodoc/transform';
+import type { ExtensionAuto } from '../../../../core';
+export declare type HighlightLangMap = Options['highlightLangs'];
+export declare type CodeBlockHighlightOptions = {
+    langs?: HighlightLangMap;
+};
+export declare const CodeBlockHighlight: ExtensionAuto<CodeBlockHighlightOptions>;