@gravity-ui/markdown-editor 13.0.0

package/build/esm/extensions/markdown/Heading/HeadingSpecs/index.js

@@ -0,0 +1,51 @@
+import { nodeTypeFactory } from '../../../../utils/schema';
+export const headingNodeName = 'heading';
+export const headingLevelAttr = 'level';
+export const headingLineNumberAttr = 'data-line';
+export const headingType = nodeTypeFactory(headingNodeName);
+const DEFAULT_PLACEHOLDER = (node) => 'Heading ' + node.attrs[headingLevelAttr];
+export const HeadingSpecs = (builder, opts) => {
+    builder.addNode(headingNodeName, () => {
+        var _a, _b, _c;
+        return ({
+            spec: {
+                attrs: { [headingLevelAttr]: { default: 1 }, [headingLineNumberAttr]: { default: null } },
+                content: '(text | inline)*',
+                group: 'block',
+                defining: true,
+                parseDOM: [
+                    { tag: 'h1', attrs: { [headingLevelAttr]: 1 } },
+                    { tag: 'h2', attrs: { [headingLevelAttr]: 2 } },
+                    { tag: 'h3', attrs: { [headingLevelAttr]: 3 } },
+                    { tag: 'h4', attrs: { [headingLevelAttr]: 4 } },
+                    { tag: 'h5', attrs: { [headingLevelAttr]: 5 } },
+                    { tag: 'h6', attrs: { [headingLevelAttr]: 6 } },
+                ],
+                toDOM(node) {
+                    const lineNumber = node.attrs[headingLineNumberAttr];
+                    return [
+                        'h' + node.attrs[headingLevelAttr],
+                        lineNumber === null ? {} : { [headingLineNumberAttr]: lineNumber },
+                        0,
+                    ];
+                },
+                placeholder: {
+                    content: (_c = (_b = (_a = builder.context.get('placeholder')) === null || _a === void 0 ? void 0 : _a.heading) !== null && _b !== void 0 ? _b : opts.headingPlaceholder) !== null && _c !== void 0 ? _c : DEFAULT_PLACEHOLDER,
+                    alwaysVisible: true,
+                },
+            },
+            fromMd: {
+                tokenSpec: {
+                    name: headingNodeName,
+                    type: 'block',
+                    getAttrs: (tok) => ({ [headingLevelAttr]: Number(tok.tag.slice(1)) }),
+                },
+            },
+            toMd: (state, node) => {
+                state.write(state.repeat('#', node.attrs[headingLevelAttr]) + ' ');
+                state.renderInline(node);
+                state.closeBlock(node);
+            },
+        });
+    });
+};

package/build/esm/extensions/markdown/Heading/actions.d.ts

@@ -0,0 +1,4 @@
+import type { NodeType } from 'prosemirror-model';
+import type { ActionSpec } from '../../../core';
+import { HeadingLevel } from './const';
+export declare const headingAction: (nodeType: NodeType, level: HeadingLevel) => ActionSpec;

package/build/esm/extensions/markdown/Heading/actions.js

@@ -0,0 +1,11 @@
+import { setBlockType } from 'prosemirror-commands';
+import { headingLevelAttr } from './const';
+import { hasParentHeading } from './utils';
+export const headingAction = (nodeType, level) => {
+    const cmd = setBlockType(nodeType, { [headingLevelAttr]: level });
+    return {
+        isActive: hasParentHeading(level),
+        isEnable: cmd,
+        run: cmd,
+    };
+};

package/build/esm/extensions/markdown/Heading/commands.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from 'prosemirror-state';
+export declare const resetHeading: Command;

package/build/esm/extensions/markdown/Heading/commands.js

@@ -0,0 +1,11 @@
+import { toParagraph } from '../../base/BaseSchema';
+import { hType } from './utils';
+export const resetHeading = (state, dispatch, view) => {
+    const { selection } = state;
+    if (selection.empty &&
+        selection.$from.parent.type === hType(state.schema) &&
+        (view === null || view === void 0 ? void 0 : view.endOfTextblock('backward', state))) {
+        return toParagraph(state, dispatch, view);
+    }
+    return false;
+};

package/build/esm/extensions/markdown/Heading/const.d.ts

@@ -0,0 +1,10 @@
+export { headingNodeName, headingLevelAttr } from './HeadingSpecs';
+export declare type HeadingLevel = 1 | 2 | 3 | 4 | 5 | 6;
+export declare enum HeadingAction {
+    ToH1 = "toH1",
+    ToH2 = "toH2",
+    ToH3 = "toH3",
+    ToH4 = "toH4",
+    ToH5 = "toH5",
+    ToH6 = "toH6"
+}

package/build/esm/extensions/markdown/Heading/const.js

@@ -0,0 +1,10 @@
+export { headingNodeName, headingLevelAttr } from './HeadingSpecs';
+export var HeadingAction;
+(function (HeadingAction) {
+    HeadingAction["ToH1"] = "toH1";
+    HeadingAction["ToH2"] = "toH2";
+    HeadingAction["ToH3"] = "toH3";
+    HeadingAction["ToH4"] = "toH4";
+    HeadingAction["ToH5"] = "toH5";
+    HeadingAction["ToH6"] = "toH6";
+})(HeadingAction || (HeadingAction = {}));

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

@@ -0,0 +1,27 @@
+import type { Action, ExtensionAuto } from '../../../core';
+import { HeadingSpecsOptions } from './HeadingSpecs';
+import { HeadingAction } from './const';
+export { headingNodeName, headingType } from './HeadingSpecs';
+export { HeadingAction } from './const';
+export { hType } from './utils';
+export declare type HeadingOptions = HeadingSpecsOptions & {
+    h1Key?: string | null;
+    h2Key?: string | null;
+    h3Key?: string | null;
+    h4Key?: string | null;
+    h5Key?: string | null;
+    h6Key?: string | null;
+};
+export declare const Heading: ExtensionAuto<HeadingOptions>;
+declare global {
+    namespace WysiwygEditor {
+        interface Actions {
+            [HeadingAction.ToH1]: Action;
+            [HeadingAction.ToH2]: Action;
+            [HeadingAction.ToH3]: Action;
+            [HeadingAction.ToH4]: Action;
+            [HeadingAction.ToH5]: Action;
+            [HeadingAction.ToH6]: Action;
+        }
+    }
+}

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

@@ -0,0 +1,40 @@
+import { setBlockType } from 'prosemirror-commands';
+import { withLogAction } from '../../../utils/keymap';
+import { HeadingSpecs } from './HeadingSpecs';
+import { headingAction } from './actions';
+import { resetHeading } from './commands';
+import { HeadingAction, headingLevelAttr } from './const';
+import { hType, headingRule } from './utils';
+export { headingNodeName, headingType } from './HeadingSpecs';
+export { HeadingAction } from './const';
+export { hType } from './utils';
+export const Heading = (builder, opts) => {
+    builder.use(HeadingSpecs, opts);
+    builder
+        .addKeymap(({ schema }) => {
+        const { h1Key, h2Key, h3Key, h4Key, h5Key, h6Key } = opts !== null && opts !== void 0 ? opts : {};
+        const cmd4lvl = (level) => setBlockType(hType(schema), { [headingLevelAttr]: level });
+        const bindings = { Backspace: resetHeading };
+        if (h1Key)
+            bindings[h1Key] = withLogAction('heading1', cmd4lvl(1));
+        if (h2Key)
+            bindings[h2Key] = withLogAction('heading2', cmd4lvl(2));
+        if (h3Key)
+            bindings[h3Key] = withLogAction('heading3', cmd4lvl(3));
+        if (h4Key)
+            bindings[h4Key] = withLogAction('heading4', cmd4lvl(4));
+        if (h5Key)
+            bindings[h5Key] = withLogAction('heading5', cmd4lvl(5));
+        if (h6Key)
+            bindings[h6Key] = withLogAction('heading6', cmd4lvl(6));
+        return bindings;
+    })
+        .addInputRules(({ schema }) => ({ rules: [headingRule(hType(schema), 6)] }));
+    builder
+        .addAction(HeadingAction.ToH1, ({ schema }) => headingAction(hType(schema), 1))
+        .addAction(HeadingAction.ToH2, ({ schema }) => headingAction(hType(schema), 2))
+        .addAction(HeadingAction.ToH3, ({ schema }) => headingAction(hType(schema), 3))
+        .addAction(HeadingAction.ToH4, ({ schema }) => headingAction(hType(schema), 4))
+        .addAction(HeadingAction.ToH5, ({ schema }) => headingAction(hType(schema), 5))
+        .addAction(HeadingAction.ToH6, ({ schema }) => headingAction(hType(schema), 6));
+};

package/build/esm/extensions/markdown/Heading/utils.d.ts

@@ -0,0 +1,7 @@
+import type { NodeType } from 'prosemirror-model';
+import type { EditorState } from 'prosemirror-state';
+import { HeadingLevel } from './const';
+/** @deprecated Use `headingType` instead */
+export declare const hType: (schema: import("prosemirror-model").Schema<any, any>) => NodeType;
+export declare const hasParentHeading: (level: HeadingLevel) => (state: EditorState) => boolean;
+export declare function headingRule(nodeType: NodeType, maxLevel: HeadingLevel): import("prosemirror-inputrules").InputRule;

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

@@ -0,0 +1,16 @@
+import { hasParentNode } from 'prosemirror-utils';
+import { textblockTypeInputRule } from '../../../utils/inputrules';
+import { headingType } from './HeadingSpecs';
+import { headingLevelAttr } from './const';
+/** @deprecated Use `headingType` instead */
+export const hType = headingType;
+export const hasParentHeading = (level) => (state) => hasParentNode((node) => {
+    return node.type === headingType(state.schema) && node.attrs[headingLevelAttr] === level;
+})(state.selection);
+// Given a node type and a maximum level, creates an input rule that
+// turns up to that number of `#` characters followed by a space at
+// the start of a textblock into a heading whose level corresponds to
+// the number of `#` signs.
+export function headingRule(nodeType, maxLevel) {
+    return textblockTypeInputRule(new RegExp('^(#{1,' + maxLevel + '})\\s$'), nodeType, (match) => ({ [headingLevelAttr]: match[1].length }));
+}

package/build/esm/extensions/markdown/HorizontalRule/HorizontalRuleSpecs/index.d.ts

@@ -0,0 +1,5 @@
+import type { ExtensionAuto } from '../../../../core';
+export declare const horizontalRuleNodeName = "horizontal_rule";
+export declare const horizontalRuleMarkupAttr = "markup";
+export declare const horizontalRuleType: (schema: import("prosemirror-model").Schema<any, any>) => import("prosemirror-model").NodeType;
+export declare const HorizontalRuleSpecs: ExtensionAuto;

package/build/esm/extensions/markdown/HorizontalRule/HorizontalRuleSpecs/index.js

@@ -0,0 +1,28 @@
+import { nodeTypeFactory } from '../../../../utils/schema';
+export const horizontalRuleNodeName = 'horizontal_rule';
+export const horizontalRuleMarkupAttr = 'markup';
+export const horizontalRuleType = nodeTypeFactory(horizontalRuleNodeName);
+export const HorizontalRuleSpecs = (builder) => {
+    builder.addNode(horizontalRuleNodeName, () => ({
+        spec: {
+            attrs: { [horizontalRuleMarkupAttr]: { default: '---' } },
+            group: 'block',
+            parseDOM: [{ tag: 'hr' }],
+            toDOM() {
+                return ['div', ['hr']];
+            },
+        },
+        fromMd: {
+            tokenName: 'hr',
+            tokenSpec: {
+                name: horizontalRuleNodeName,
+                type: 'node',
+                getAttrs: (token) => ({ [horizontalRuleMarkupAttr]: token.markup }),
+            },
+        },
+        toMd: (state, node) => {
+            state.write(node.attrs[horizontalRuleMarkupAttr]);
+            state.closeBlock(node);
+        },
+    }));
+};

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

@@ -0,0 +1,15 @@
+import type { Action, ExtensionAuto } from '../../../core';
+export { horizontalRuleMarkupAttr, horizontalRuleNodeName, horizontalRuleType, } from './HorizontalRuleSpecs';
+/** @deprecated Use `horizontalRuleNodeName` instead */
+export declare const horizontalRule = "horizontal_rule";
+declare const hrAction = "hRule";
+/** @deprecated Use `horizontalRuleMarkupAttr` instead */
+export declare const markupAttr = "markup";
+export declare const HorizontalRule: ExtensionAuto;
+declare global {
+    namespace WysiwygEditor {
+        interface Actions {
+            [hrAction]: Action;
+        }
+    }
+}

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

@@ -0,0 +1,63 @@
+import { TextSelection } from 'prosemirror-state';
+import { nodeInputRule } from '../../../utils/inputrules';
+import { get$Cursor, isNodeSelection } from '../../../utils/selection';
+import { pType } from '../../base/BaseSchema/BaseSchemaSpecs';
+import { HorizontalRuleSpecs, horizontalRuleMarkupAttr, horizontalRuleNodeName, horizontalRuleType, } from './HorizontalRuleSpecs';
+export { horizontalRuleMarkupAttr, horizontalRuleNodeName, horizontalRuleType, } from './HorizontalRuleSpecs';
+/** @deprecated Use `horizontalRuleNodeName` instead */
+export const horizontalRule = horizontalRuleNodeName;
+const hrAction = 'hRule';
+/** @deprecated Use `horizontalRuleMarkupAttr` instead */
+export const markupAttr = horizontalRuleMarkupAttr;
+/** @deprecated Use `horizontalRuleType` instead */
+const hrType = horizontalRuleType;
+export const HorizontalRule = (builder) => {
+    builder.use(HorizontalRuleSpecs);
+    builder.addInputRules((deps) => ({
+        rules: [
+            // --- or ___ or *** at start of line are converted to horizontal line
+            // and add new empty paragraph after
+            nodeInputRule(/^(---|___|\*\*\*)$/, (markup) => [
+                hrType(deps.schema).create({ [horizontalRuleMarkupAttr]: markup }),
+                pType(deps.schema).create(),
+            ], 1),
+        ],
+    }));
+    builder.addAction(hrAction, ({ schema }) => {
+        const cmd = addHr(hrType(schema));
+        return {
+            isActive: (state) => isHrSelection(state.selection),
+            isEnable: cmd,
+            run: cmd,
+        };
+    });
+};
+const addHr = (hr) => (state, dispatch) => {
+    if (isHrSelection(state.selection))
+        return true;
+    if (isNodeSelection(state.selection)) {
+        dispatch === null || dispatch === void 0 ? void 0 : dispatch(state.tr.replaceSelectionWith(hr.create()).scrollIntoView());
+        return true;
+    }
+    const $cursor = get$Cursor(state.selection);
+    if (!$cursor || $cursor.parent.type.spec.complex)
+        return false;
+    if (!dispatch)
+        return true;
+    const { tr } = state;
+    const isEmptyParagraph = $cursor.parent.type === pType(state.schema) && $cursor.parent.nodeSize === 2;
+    if (isEmptyParagraph) {
+        const pos = $cursor.before();
+        tr.insert(pos, hr.create());
+    }
+    else {
+        const pos = $cursor.after();
+        tr.insert(pos, [hr.create(), pType(state.schema).create()]);
+        tr.setSelection(TextSelection.create(tr.doc, pos + 2)); // set cursor to paragraph after hr
+    }
+    dispatch(tr.scrollIntoView());
+    return true;
+};
+function isHrSelection(selection) {
+    return isNodeSelection(selection) && selection.node.type.name === horizontalRuleNodeName;
+}

package/build/esm/extensions/markdown/Html/const.d.ts

@@ -0,0 +1,7 @@
+export declare enum HtmlNode {
+    Block = "html_block",
+    Inline = "html_inline"
+}
+export declare enum HtmlAttr {
+    Content = "html-content"
+}

package/build/esm/extensions/markdown/Html/const.js

@@ -0,0 +1,9 @@
+export var HtmlNode;
+(function (HtmlNode) {
+    HtmlNode["Block"] = "html_block";
+    HtmlNode["Inline"] = "html_inline";
+})(HtmlNode || (HtmlNode = {}));
+export var HtmlAttr;
+(function (HtmlAttr) {
+    HtmlAttr["Content"] = "html-content";
+})(HtmlAttr || (HtmlAttr = {}));

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

@@ -0,0 +1,13 @@
+import type { ExtensionAuto } from '../../../core';
+export { HtmlAttr, HtmlNode } from './const';
+export declare const Html: ExtensionAuto;
+declare global {
+    namespace WysiwygEditor {
+        interface Context {
+            /**
+             * Same as @type {MarkdownIt.Options.html}
+             */
+            html: boolean;
+        }
+    }
+}

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

@@ -0,0 +1,22 @@
+import { logger } from '../../../logger';
+import { HtmlNode } from './const';
+import { parserTokens } from './parser';
+import { schemaSpecs } from './schema';
+import { serializerTokens } from './serializer';
+export { HtmlAttr, HtmlNode } from './const';
+export const Html = (builder) => {
+    if (builder.context.has('html') && builder.context.get('html') === false) {
+        logger.info('[HTML extension]: Skip extension, because HTML disabled via context');
+        return;
+    }
+    builder.addNode(HtmlNode.Block, () => ({
+        spec: schemaSpecs[HtmlNode.Block],
+        fromMd: { tokenSpec: parserTokens[HtmlNode.Block] },
+        toMd: serializerTokens[HtmlNode.Block],
+    }));
+    builder.addNode(HtmlNode.Inline, () => ({
+        spec: schemaSpecs[HtmlNode.Inline],
+        fromMd: { tokenSpec: parserTokens[HtmlNode.Inline] },
+        toMd: serializerTokens[HtmlNode.Inline],
+    }));
+};

package/build/esm/extensions/markdown/Html/parser.d.ts

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

package/build/esm/extensions/markdown/Html/parser.js

@@ -0,0 +1,19 @@
+import { HtmlAttr, HtmlNode } from './const';
+export const parserTokens = {
+    [HtmlNode.Block]: {
+        name: HtmlNode.Block,
+        type: 'node',
+        noCloseToken: true,
+        getAttrs: (token) => ({
+            [HtmlAttr.Content]: token.content,
+        }),
+    },
+    [HtmlNode.Inline]: {
+        name: HtmlNode.Inline,
+        type: 'node',
+        noCloseToken: true,
+        getAttrs: (token) => ({
+            [HtmlAttr.Content]: token.content,
+        }),
+    },
+};

package/build/esm/extensions/markdown/Html/schema.d.ts

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

package/build/esm/extensions/markdown/Html/schema.js

@@ -0,0 +1,55 @@
+import sanitize from '@diplodoc/transform/lib/sanitize';
+import { HtmlAttr, HtmlNode } from './const';
+var DomAttr;
+(function (DomAttr) {
+    DomAttr["Html"] = "data-html";
+    DomAttr["HtmlRaw"] = "data-html-raw";
+})(DomAttr || (DomAttr = {}));
+export const schemaSpecs = {
+    [HtmlNode.Block]: {
+        atom: true,
+        group: 'block',
+        attrs: { [HtmlAttr.Content]: {} },
+        parseDOM: [
+            {
+                tag: `div[${DomAttr.Html}]`,
+                getAttrs(dom) {
+                    const dom_ = dom;
+                    return {
+                        [HtmlAttr.Content]: dom_.getAttribute(DomAttr.HtmlRaw) || dom_.innerHTML,
+                    };
+                },
+            },
+        ],
+        toDOM(node) {
+            const htmlContent = node.attrs[HtmlAttr.Content];
+            const elem = document.createElement('div');
+            elem.setAttribute(DomAttr.Html, '');
+            elem.setAttribute(DomAttr.HtmlRaw, htmlContent);
+            elem.contentEditable = 'false';
+            elem.innerHTML = sanitize(htmlContent);
+            return elem;
+        },
+    },
+    [HtmlNode.Inline]: {
+        atom: true,
+        inline: true,
+        group: 'inline',
+        attrs: { [HtmlAttr.Content]: {} },
+        parseDOM: [
+            {
+                tag: `span[${DomAttr.Html}]`,
+                getAttrs(dom) {
+                    return { [HtmlAttr.Content]: dom.textContent };
+                },
+            },
+        ],
+        toDOM(node) {
+            const elem = document.createElement('span');
+            elem.setAttribute(DomAttr.Html, '');
+            elem.contentEditable = 'false';
+            elem.textContent = node.attrs[HtmlAttr.Content];
+            return elem;
+        },
+    },
+};

package/build/esm/extensions/markdown/Html/serializer.d.ts

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

package/build/esm/extensions/markdown/Html/serializer.js

@@ -0,0 +1,11 @@
+import { HtmlAttr, HtmlNode } from './const';
+export const serializerTokens = {
+    [HtmlNode.Block]: (state, node) => {
+        state.write(node.attrs[HtmlAttr.Content]);
+        state.ensureNewLine();
+        state.closeBlock(node);
+    },
+    [HtmlNode.Inline]: (state, node) => {
+        state.write(node.attrs[HtmlAttr.Content]);
+    },
+};

package/build/esm/extensions/markdown/Image/ImageSpecs/index.d.ts

@@ -0,0 +1,10 @@
+import type { ExtensionAuto } from '../../../../core';
+export declare const imageNodeName = "image";
+export declare const imageType: (schema: import("prosemirror-model").Schema<any, any>) => import("prosemirror-model").NodeType;
+export declare const ImageAttr: {
+    readonly Src: "src";
+    readonly Alt: "alt";
+    readonly Title: "title";
+    readonly Loading: "loading";
+};
+export declare const ImageSpecs: ExtensionAuto;

package/build/esm/extensions/markdown/Image/ImageSpecs/index.js

@@ -0,0 +1,63 @@
+import { nodeTypeFactory } from '../../../../utils/schema';
+export const imageNodeName = 'image';
+export const imageType = nodeTypeFactory(imageNodeName);
+export const ImageAttr = {
+    Src: 'src',
+    Alt: 'alt',
+    Title: 'title',
+    Loading: 'loading',
+};
+export const ImageSpecs = (builder) => {
+    builder.addNode(imageNodeName, () => ({
+        spec: {
+            inline: true,
+            attrs: {
+                [ImageAttr.Src]: {},
+                [ImageAttr.Alt]: { default: null },
+                [ImageAttr.Title]: { default: null },
+                [ImageAttr.Loading]: { default: null },
+            },
+            group: 'inline',
+            draggable: true,
+            parseDOM: [
+                {
+                    tag: 'img[src]',
+                    getAttrs(dom) {
+                        return {
+                            [ImageAttr.Src]: dom.getAttribute(ImageAttr.Src),
+                            [ImageAttr.Alt]: dom.getAttribute(ImageAttr.Alt),
+                            [ImageAttr.Title]: dom.getAttribute(ImageAttr.Title),
+                            [ImageAttr.Loading]: dom.getAttribute(ImageAttr.Loading),
+                        };
+                    },
+                },
+            ],
+            toDOM(node) {
+                return ['img', node.attrs];
+            },
+        },
+        fromMd: {
+            tokenSpec: {
+                name: imageNodeName,
+                type: 'node',
+                getAttrs: (tok) => {
+                    var _a, _b;
+                    return ({
+                        [ImageAttr.Src]: tok.attrGet('src'),
+                        [ImageAttr.Title]: tok.attrGet('title') || null,
+                        [ImageAttr.Loading]: tok.attrGet(ImageAttr.Loading) || null,
+                        [ImageAttr.Alt]: ((_b = (_a = tok.children) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.content) || null,
+                    });
+                },
+            },
+        },
+        toMd: (state, { attrs }) => {
+            state.write('![' +
+                state.esc(attrs.alt || '') +
+                '](' +
+                state.esc(attrs.src) +
+                (attrs.title ? ' ' + state.quote(attrs.title) : '') +
+                ')');
+        },
+    }));
+};

package/build/esm/extensions/markdown/Image/actions.d.ts

@@ -0,0 +1,8 @@
+import type { Schema } from 'prosemirror-model';
+import type { ActionSpec } from '../../../core';
+export declare type AddImageAttrs = {
+    src: string;
+    title?: string;
+    alt?: string;
+};
+export declare const addImage: (schema: Schema) => ActionSpec;

package/build/esm/extensions/markdown/Image/actions.js

@@ -0,0 +1,19 @@
+import { imageType } from './ImageSpecs';
+import { ImageAttr } from './const';
+export const addImage = (schema) => {
+    return {
+        isEnable: (state) => state.selection.empty,
+        run(state, dispatch, _view, attrs) {
+            const params = attrs;
+            if (params === null || params === void 0 ? void 0 : params.src) {
+                const { src, title, alt } = params;
+                const imgAttrs = {
+                    [ImageAttr.Src]: src,
+                    [ImageAttr.Title]: title !== null && title !== void 0 ? title : '',
+                    [ImageAttr.Alt]: alt !== null && alt !== void 0 ? alt : '',
+                };
+                dispatch(state.tr.insert(state.selection.from, imageType(schema).create(imgAttrs)));
+            }
+        },
+    };
+};

package/build/esm/extensions/markdown/Image/const.d.ts

@@ -0,0 +1,2 @@
+export { imageNodeName, ImageAttr } from './ImageSpecs';
+export declare const addImageAction = "addImage";

package/build/esm/extensions/markdown/Image/const.js

@@ -0,0 +1,2 @@
+export { imageNodeName, ImageAttr } from './ImageSpecs';
+export const addImageAction = 'addImage';

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

@@ -0,0 +1,15 @@
+import type { Action, ExtensionAuto } from '../../../core';
+import { AddImageAttrs } from './actions';
+import { addImageAction } from './const';
+export { imageNodeName, imageType, ImageAttr } from './ImageSpecs';
+/** @deprecated Use `imageType` instead */
+export declare const imgType: (schema: import("prosemirror-model").Schema<any, any>) => import("prosemirror-model").NodeType;
+export type { AddImageAttrs } from './actions';
+export declare const Image: ExtensionAuto;
+declare global {
+    namespace WysiwygEditor {
+        interface Actions {
+            [addImageAction]: Action<AddImageAttrs>;
+        }
+    }
+}

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

@@ -0,0 +1,10 @@
+import { ImageSpecs, imageType } from './ImageSpecs';
+import { addImage } from './actions';
+import { addImageAction } from './const';
+export { imageNodeName, imageType, ImageAttr } from './ImageSpecs';
+/** @deprecated Use `imageType` instead */
+export const imgType = imageType;
+export const Image = (builder) => {
+    builder.use(ImageSpecs);
+    builder.addAction(addImageAction, ({ schema }) => addImage(schema));
+};

package/build/esm/extensions/markdown/Italic/ItalicSpecs/index.d.ts

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