@gravity-ui/markdown-editor 13.0.0

package/build/esm/extensions/markdown/Link/plugins/LinkTooltipPlugin/index.js

@@ -0,0 +1,196 @@
+import React from 'react';
+import { Popup } from '@gravity-ui/uikit';
+import { keydownHandler } from 'prosemirror-keymap';
+import { Plugin, TextSelection } from 'prosemirror-state';
+import { findChildrenByMark, findParentNode } from 'prosemirror-utils';
+import { Decoration, DecorationSet } from 'prosemirror-view';
+import { ErrorLoggerBoundary } from '../../../../../react-utils/ErrorBoundary';
+import { findMark, isMarkActive } from '../../../../../utils/marks';
+import { getReactRendererFromState } from '../../../../behavior/ReactRenderer';
+import { LinkAttr, linkType, normalizeUrlFactory } from '../../../index';
+import { LinkForm } from './TooltipView';
+const className = 'pm-link-focus-deco';
+const placement = ['bottom-start', 'bottom-end', 'top-start', 'top-end'];
+function getTextNode(state) {
+    if (!(state.selection instanceof TextSelection) ||
+        !state.selection.empty ||
+        !isMarkActive(state, linkType(state.schema)))
+        return null;
+    const parent = findParentNode(Boolean)(state.selection);
+    if (!parent) {
+        return null;
+    }
+    const textNodes = findChildrenByMark(parent === null || parent === void 0 ? void 0 : parent.node, linkType(state.schema));
+    const textNode = textNodes.find((n) => {
+        const start = n.pos + parent.pos;
+        const end = start + n.node.nodeSize;
+        return start <= state.selection.from && end >= state.selection.from;
+    });
+    if (!textNode)
+        return null;
+    const absolutePos = textNode.pos + parent.pos + 1;
+    return Object.assign(Object.assign({}, textNode), { absolutePos,
+        parent, from: absolutePos, to: absolutePos + textNode.node.nodeSize });
+}
+export const linkTooltipPlugin = (deps) => {
+    let viewTooltip = null;
+    return new Plugin({
+        view(view) {
+            viewTooltip = new SelectionTooltip(view, deps);
+            return viewTooltip;
+        },
+        props: {
+            handleKeyDown: keydownHandler({
+                Escape: () => { var _a; return (_a = viewTooltip === null || viewTooltip === void 0 ? void 0 : viewTooltip.onEscapeDown()) !== null && _a !== void 0 ? _a : false; },
+            }),
+            decorations(state) {
+                const textNode = getTextNode(state);
+                if (!textNode)
+                    return DecorationSet.empty;
+                const { from, to } = textNode;
+                return DecorationSet.create(state.doc, [
+                    Decoration.inline(from, to, {
+                        class: `pm-node-selected ${className}`,
+                    }),
+                ]);
+            },
+        },
+    });
+};
+class SelectionTooltip {
+    constructor(view, deps) {
+        this.isTooltipOpen = false;
+        this.manualHidden = false;
+        this.selectionTooltipProps = { show: false };
+        this.onOutisdeClick = () => {
+            // after all updates of the editor state
+            setTimeout(() => {
+                if (!this.view.hasFocus()) {
+                    this.removePlaceholderLink(this.textNode);
+                    this.hideTooltip();
+                    this.manualHidden = false;
+                }
+            });
+        };
+        this.normalizeUrl = normalizeUrlFactory(deps);
+        this.view = view;
+        this.update(view, null);
+    }
+    update(view, prevState) {
+        if (!view.dom.parentNode) {
+            this.hideTooltip();
+            return;
+        }
+        const { state } = view;
+        if (prevState && prevState.doc.eq(state.doc) && prevState.selection.eq(state.selection))
+            return;
+        const prevTextNode = this.textNode;
+        this.textNode = getTextNode(view.state);
+        const prevRef = this.textNodeRef;
+        this.updateTextNodeRef();
+        if (!this.textNode || !this.textNodeRef) {
+            this.removePlaceholderLink(prevTextNode);
+            this.hideTooltip();
+            return;
+        }
+        if (prevRef !== this.textNodeRef) {
+            this.manualHidden = false;
+        }
+        if (this.manualHidden) {
+            this.hideTooltip();
+        }
+        else {
+            this.renderTooltip({
+                show: true,
+                domElem: this.textNodeRef,
+                onCancel: () => this.cancelPopup(),
+                attrs: this.getMarkAttrs(),
+                onChange: this.changeAttrs.bind(this),
+                onOutsideClick: this.onOutisdeClick,
+            });
+        }
+    }
+    destroy() {
+        var _a;
+        this.isTooltipOpen = false;
+        this.selectionTooltipProps = { show: false };
+        (_a = this.renderItem) === null || _a === void 0 ? void 0 : _a.remove();
+        this.renderItem = undefined;
+    }
+    onEscapeDown() {
+        if (this.isTooltipOpen) {
+            this.removePlaceholderLink(this.textNode);
+            this.manualHidden = true;
+            this.hideTooltip();
+            return true;
+        }
+        return false;
+    }
+    updateTextNodeRef() {
+        const decoElem = this.view.dom.getElementsByClassName(className)[0];
+        this.textNodeRef = decoElem;
+    }
+    getMarkAttrs() {
+        const { textNode } = this;
+        const linkMark = textNode && findMark(textNode.node, linkType(this.view.state.schema));
+        return linkMark === null || linkMark === void 0 ? void 0 : linkMark.attrs;
+    }
+    hideTooltip() {
+        this.renderTooltip({ show: false });
+    }
+    renderTooltip(props) {
+        var _a;
+        this.isTooltipOpen = props.show;
+        this.selectionTooltipProps = props;
+        this.renderItem = (_a = this.renderItem) !== null && _a !== void 0 ? _a : this.createRenderItem();
+        this.renderItem.rerender();
+    }
+    cancelPopup() {
+        this.removePlaceholderLink(this.textNode, { returnSelection: true });
+        this.manualHidden = true;
+        this.hideTooltip();
+        this.view.focus();
+    }
+    removePlaceholderLink(textNode, opts) {
+        var _a;
+        if (textNode) {
+            const { view } = this;
+            const { state } = view;
+            const attrs = (_a = findMark(textNode.node, linkType(state.schema))) === null || _a === void 0 ? void 0 : _a.attrs;
+            if (attrs === null || attrs === void 0 ? void 0 : attrs[LinkAttr.IsPlaceholder]) {
+                const { from, to } = textNode;
+                let tr = state.tr.removeMark(from, to, linkType(state.schema));
+                if (opts === null || opts === void 0 ? void 0 : opts.returnSelection) {
+                    tr = tr.setSelection(TextSelection.create(tr.doc, from, to));
+                }
+                view.dispatch(tr);
+            }
+        }
+    }
+    changeAttrs({ href }) {
+        const { view, textNode } = this;
+        if (!textNode)
+            return;
+        const normalizeResult = this.normalizeUrl(href);
+        if (normalizeResult) {
+            const { url } = normalizeResult;
+            const { from, to } = textNode;
+            view.dispatch(view.state.tr.addMark(from, to, linkType(view.state.schema).create({ href: url })));
+            setTimeout(this.cancelPopup.bind(this));
+        }
+    }
+    createRenderItem() {
+        return getReactRendererFromState(this.view.state).createItem('link-tooltip', () => (React.createElement(ErrorLoggerBoundary, null,
+            React.createElement(SelectionTooltipView, Object.assign({}, this.selectionTooltipProps)))));
+    }
+}
+const SelectionTooltipView = (props) => {
+    const { show } = props;
+    if (!show)
+        return null;
+    const { domElem, onChange, onCancel, onOutsideClick, attrs = {} } = props;
+    const href = attrs[LinkAttr.Href];
+    const autoFocus = attrs[LinkAttr.IsPlaceholder];
+    return (React.createElement(Popup, { key: href, open: true, anchorRef: { current: domElem }, placement: placement, onEscapeKeyDown: onCancel, onOutsideClick: onOutsideClick },
+        React.createElement(LinkForm, { href: href !== null && href !== void 0 ? href : '', autoFocus: autoFocus, onChange: onChange, onCancel: onCancel })));
+};

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

@@ -0,0 +1,5 @@
+import type { ExtensionDeps } from '../../../core';
+export declare const normalizeUrlFactory: ({ markupParser }: ExtensionDeps) => (url: string) => {
+    url: string;
+    text: string;
+} | null;

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

@@ -0,0 +1,17 @@
+const isString = (str) => typeof str === 'string';
+const notEmpty = (str) => str.length > 0;
+export const normalizeUrlFactory = ({ markupParser: parser }) => (url) => {
+    if (isString(url)) {
+        url = url.trim();
+        if (notEmpty(url)) {
+            url = parser.normalizeLink(url);
+            if (parser.validateLink(url)) {
+                return {
+                    url,
+                    text: parser.normalizeLinkText(url),
+                };
+            }
+        }
+    }
+    return null;
+};

package/build/esm/extensions/markdown/Lists/ListsSpecs/const.d.ts

@@ -0,0 +1,5 @@
+export declare enum ListNode {
+    ListItem = "list_item",
+    BulletList = "bullet_list",
+    OrderedList = "ordered_list"
+}

package/build/esm/extensions/markdown/Lists/ListsSpecs/const.js

@@ -0,0 +1,6 @@
+export var ListNode;
+(function (ListNode) {
+    ListNode["ListItem"] = "list_item";
+    ListNode["BulletList"] = "bullet_list";
+    ListNode["OrderedList"] = "ordered_list";
+})(ListNode || (ListNode = {}));

package/build/esm/extensions/markdown/Lists/ListsSpecs/index.d.ts

@@ -0,0 +1,6 @@
+import type { ExtensionAuto } from '../../../../core';
+export { ListNode } from './const';
+export declare const liType: (schema: import("prosemirror-model").Schema<any, any>) => import("prosemirror-model").NodeType;
+export declare const blType: (schema: import("prosemirror-model").Schema<any, any>) => import("prosemirror-model").NodeType;
+export declare const olType: (schema: import("prosemirror-model").Schema<any, any>) => import("prosemirror-model").NodeType;
+export declare const ListsSpecs: ExtensionAuto;

package/build/esm/extensions/markdown/Lists/ListsSpecs/index.js

@@ -0,0 +1,27 @@
+import { nodeTypeFactory } from '../../../../utils/schema';
+import { ListNode } from './const';
+import { parserTokens } from './parser';
+import { schemaSpecs } from './schema';
+import { serializerTokens } from './serializer';
+export { ListNode } from './const';
+export const liType = nodeTypeFactory(ListNode.ListItem);
+export const blType = nodeTypeFactory(ListNode.BulletList);
+export const olType = nodeTypeFactory(ListNode.OrderedList);
+export const ListsSpecs = (builder) => {
+    builder
+        .addNode(ListNode.ListItem, () => ({
+        spec: schemaSpecs[ListNode.ListItem],
+        toMd: serializerTokens[ListNode.ListItem],
+        fromMd: { tokenSpec: parserTokens[ListNode.ListItem] },
+    }))
+        .addNode(ListNode.BulletList, () => ({
+        spec: schemaSpecs[ListNode.BulletList],
+        toMd: serializerTokens[ListNode.BulletList],
+        fromMd: { tokenSpec: parserTokens[ListNode.BulletList] },
+    }))
+        .addNode(ListNode.OrderedList, () => ({
+        spec: schemaSpecs[ListNode.OrderedList],
+        toMd: serializerTokens[ListNode.OrderedList],
+        fromMd: { tokenSpec: parserTokens[ListNode.OrderedList] },
+    }));
+};

package/build/esm/extensions/markdown/Lists/ListsSpecs/parser.d.ts

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

package/build/esm/extensions/markdown/Lists/ListsSpecs/parser.js

@@ -0,0 +1,24 @@
+import { ListNode } from './const';
+export const parserTokens = {
+    [ListNode.ListItem]: { name: ListNode.ListItem, type: 'block' },
+    [ListNode.BulletList]: {
+        name: ListNode.BulletList,
+        type: 'block',
+        getAttrs: (_, tokens, i) => ({ tight: listIsTight(tokens, i) }),
+    },
+    [ListNode.OrderedList]: {
+        name: ListNode.OrderedList,
+        type: 'block',
+        getAttrs: (tok, tokens, i) => ({
+            order: Number(tok.attrGet('start')) || 1,
+            tight: listIsTight(tokens, i),
+        }),
+    },
+};
+function listIsTight(tokens, i) {
+    while (++i < tokens.length) {
+        if (tokens[i].type !== 'list_item_open')
+            return tokens[i].hidden;
+    }
+    return false;
+}

package/build/esm/extensions/markdown/Lists/ListsSpecs/schema.d.ts

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

package/build/esm/extensions/markdown/Lists/ListsSpecs/schema.js

@@ -0,0 +1,64 @@
+import { ListNode } from './const';
+export const schemaSpecs = {
+    [ListNode.ListItem]: {
+        attrs: { tight: { default: false } },
+        content: '(paragraph|block)+',
+        defining: true,
+        parseDOM: [{ tag: 'li' }],
+        toDOM() {
+            return ['li', 0];
+        },
+        selectable: true,
+        allowSelection: false,
+        disableGapCursor: true,
+        complex: 'leaf',
+    },
+    [ListNode.BulletList]: {
+        content: `${ListNode.ListItem}+`,
+        group: 'block',
+        attrs: { tight: { default: false } },
+        parseDOM: [
+            {
+                tag: 'ul',
+                getAttrs: (dom) => ({ tight: dom.hasAttribute('data-tight') }),
+            },
+        ],
+        toDOM(node) {
+            return ['ul', { 'data-tight': node.attrs.tight ? 'true' : null }, 0];
+        },
+        selectable: false,
+        allowSelection: false,
+        complex: 'root',
+    },
+    [ListNode.OrderedList]: {
+        attrs: { order: { default: 1 }, tight: { default: false } },
+        content: `${ListNode.ListItem}+`,
+        group: 'block',
+        parseDOM: [
+            {
+                tag: 'ol',
+                getAttrs(dom) {
+                    return {
+                        order: dom.hasAttribute('start')
+                            ? Number(dom.getAttribute('start'))
+                            : 1,
+                        tight: dom.hasAttribute('data-tight'),
+                    };
+                },
+            },
+        ],
+        toDOM(node) {
+            return [
+                'ol',
+                {
+                    start: node.attrs.order === 1 ? null : node.attrs.order,
+                    'data-tight': node.attrs.tight ? 'true' : null,
+                },
+                0,
+            ];
+        },
+        selectable: false,
+        allowSelection: false,
+        complex: 'root',
+    },
+};

package/build/esm/extensions/markdown/Lists/ListsSpecs/serializer.d.ts

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

package/build/esm/extensions/markdown/Lists/ListsSpecs/serializer.js

@@ -0,0 +1,18 @@
+import { ListNode } from './const';
+export const serializerTokens = {
+    [ListNode.ListItem]: (state, node) => {
+        state.renderContent(node);
+    },
+    [ListNode.BulletList]: (state, node) => {
+        state.renderList(node, '  ', () => (node.attrs.bullet || '*') + ' ');
+    },
+    [ListNode.OrderedList]: (state, node) => {
+        const start = node.attrs.order || 1;
+        const maxW = String(start + node.childCount - 1).length;
+        const space = state.repeat(' ', maxW + 2);
+        state.renderList(node, space, (i) => {
+            const nStr = String(start + i);
+            return state.repeat(' ', maxW - nStr.length) + nStr + '. ';
+        });
+    },
+};

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

@@ -0,0 +1,7 @@
+import type { ActionSpec, ExtensionDeps } from '../../../core';
+export declare const actions: {
+    toBulletList: ({ schema }: ExtensionDeps) => ActionSpec;
+    toOrderedList: ({ schema }: ExtensionDeps) => ActionSpec;
+    liftListItem: ({ schema }: ExtensionDeps) => ActionSpec;
+    sinkListItem: ({ schema }: ExtensionDeps) => ActionSpec;
+};

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

@@ -0,0 +1,34 @@
+import { liftListItem, sinkListItem } from 'prosemirror-schema-list';
+import { toList } from './commands';
+import { ListNode } from './const';
+import { blType, isIntoListOfType, liType, olType } from './utils';
+export const actions = {
+    toBulletList: ({ schema }) => {
+        const toBulletList = toList(blType(schema));
+        return {
+            isActive: isIntoListOfType(ListNode.BulletList),
+            isEnable: toBulletList,
+            run: toBulletList,
+        };
+    },
+    toOrderedList: ({ schema }) => {
+        const toOrderedList = toList(olType(schema));
+        return {
+            isActive: isIntoListOfType(ListNode.OrderedList),
+            isEnable: toOrderedList,
+            run: toOrderedList,
+        };
+    },
+    liftListItem: ({ schema }) => {
+        return {
+            isEnable: liftListItem(liType(schema)),
+            run: liftListItem(liType(schema)),
+        };
+    },
+    sinkListItem: ({ schema }) => {
+        return {
+            isEnable: sinkListItem(liType(schema)),
+            run: sinkListItem(liType(schema)),
+        };
+    },
+};

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

@@ -0,0 +1,5 @@
+import type { NodeType } from 'prosemirror-model';
+import type { Command } from 'prosemirror-state';
+export declare function toList(listType: NodeType): Command;
+export declare const liftIfCursorIsAtBeginningOfItem: Command;
+export declare const joinPrevList: Command;

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

@@ -0,0 +1,31 @@
+import { liftListItem, wrapInList } from 'prosemirror-schema-list';
+import { joinPreviousBlock } from '../../../commands/join';
+import { get$CursorAtBlockStart } from '../../../utils/selection';
+import { findAnyParentList, isListItemNode, isListNode, isListOrItemNode, liType } from './utils';
+export function toList(listType) {
+    return (state, dispatch) => {
+        const parentList = findAnyParentList(state.schema)(state.selection);
+        if (parentList) {
+            if (listType === parentList.node.type)
+                return true;
+            dispatch === null || dispatch === void 0 ? void 0 : dispatch(state.tr.setNodeMarkup(parentList.pos, listType));
+            return true;
+        }
+        return wrapInList(listType)(state, dispatch);
+    };
+}
+export const liftIfCursorIsAtBeginningOfItem = (state, dispatch) => {
+    const $cursor = get$CursorAtBlockStart(state.selection);
+    if (!$cursor)
+        return false;
+    const { schema } = state;
+    const parentBlock = $cursor.node($cursor.depth - 1);
+    if (parentBlock.firstChild === $cursor.parent && isListItemNode(parentBlock)) {
+        return liftListItem(liType(schema))(state, dispatch);
+    }
+    return false;
+};
+export const joinPrevList = joinPreviousBlock({
+    checkPrevNode: isListNode,
+    skipNode: isListOrItemNode,
+});

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

@@ -0,0 +1,7 @@
+export { ListNode } from './ListsSpecs';
+export declare enum ListAction {
+    ToBulletList = "toBulletList",
+    ToOrderedList = "toOrderedList",
+    SinkListItem = "sinkListItem",
+    LiftListItem = "liftListItem"
+}

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

@@ -0,0 +1,8 @@
+export { ListNode } from './ListsSpecs';
+export var ListAction;
+(function (ListAction) {
+    ListAction["ToBulletList"] = "toBulletList";
+    ListAction["ToOrderedList"] = "toOrderedList";
+    ListAction["SinkListItem"] = "sinkListItem";
+    ListAction["LiftListItem"] = "liftListItem";
+})(ListAction || (ListAction = {}));

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

@@ -0,0 +1,20 @@
+import type { Action, ExtensionAuto } from '../../../core';
+import { ListAction } from './const';
+import { ListsInputRulesOptions } from './inputrules';
+export { ListNode, blType, liType, olType } from './ListsSpecs';
+export declare type ListsOptions = {
+    ulKey?: string | null;
+    olKey?: string | null;
+    ulInputRules?: ListsInputRulesOptions['bulletListInputRule'];
+};
+export declare const Lists: ExtensionAuto<ListsOptions>;
+declare global {
+    namespace WysiwygEditor {
+        interface Actions {
+            [ListAction.ToBulletList]: Action;
+            [ListAction.ToOrderedList]: Action;
+            [ListAction.SinkListItem]: Action;
+            [ListAction.LiftListItem]: Action;
+        }
+    }
+}

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

@@ -0,0 +1,33 @@
+import { chainCommands } from 'prosemirror-commands';
+import { liftListItem, sinkListItem, splitListItem } from 'prosemirror-schema-list';
+import { withLogAction } from '../../../utils/keymap';
+import { ListsSpecs, blType, liType, olType } from './ListsSpecs';
+import { actions } from './actions';
+import { joinPrevList, liftIfCursorIsAtBeginningOfItem, toList } from './commands';
+import { ListAction } from './const';
+import { ListsInputRulesExtension } from './inputrules';
+import { mergeListsPlugin } from './plugins/MergeListsPlugin';
+export { ListNode, blType, liType, olType } from './ListsSpecs';
+export const Lists = (builder, opts) => {
+    builder.use(ListsSpecs);
+    builder.addKeymap(({ schema }) => {
+        const { ulKey, olKey } = opts !== null && opts !== void 0 ? opts : {};
+        const bindings = {};
+        if (ulKey)
+            bindings[ulKey] = withLogAction('bulletList', toList(blType(schema)));
+        if (olKey)
+            bindings[olKey] = withLogAction('orderedList', toList(olType(schema)));
+        return Object.assign({ Tab: sinkListItem(liType(schema)), 'Shift-Tab': liftListItem(liType(schema)), 'Mod-[': liftListItem(liType(schema)), 'Mod-]': sinkListItem(liType(schema)) }, bindings);
+    }, builder.Priority.High);
+    builder.addKeymap(({ schema }) => ({
+        Enter: splitListItem(liType(schema)),
+        Backspace: chainCommands(liftIfCursorIsAtBeginningOfItem, joinPrevList),
+    }), builder.Priority.Low);
+    builder.use(ListsInputRulesExtension, { bulletListInputRule: opts === null || opts === void 0 ? void 0 : opts.ulInputRules });
+    builder.addPlugin(mergeListsPlugin);
+    builder
+        .addAction(ListAction.ToBulletList, actions.toBulletList)
+        .addAction(ListAction.ToOrderedList, actions.toOrderedList)
+        .addAction(ListAction.SinkListItem, actions.sinkListItem)
+        .addAction(ListAction.LiftListItem, actions.liftListItem);
+};

package/build/esm/extensions/markdown/Lists/inputrules.d.ts

@@ -0,0 +1,26 @@
+import type { NodeType } from 'prosemirror-model';
+import type { ExtensionWithOptions } from '../../../core';
+export declare type ListsInputRulesOptions = {
+    bulletListInputRule?: false | BulletListInputRuleConfig;
+};
+export declare const ListsInputRulesExtension: ExtensionWithOptions<ListsInputRulesOptions>;
+/**
+ * Given a list node type, returns an input rule that turns a number
+ * followed by a dot at the start of a textblock into an ordered list.
+ */
+export declare function orderedListRule(nodeType: NodeType): import("prosemirror-inputrules").InputRule;
+declare type BulletListInputRuleConfig = {
+    /** @default true */
+    dash?: boolean;
+    /** @default true */
+    plus?: boolean;
+    /** @default true */
+    asterisk?: boolean;
+};
+/**
+ * Given a list node type, returns an input rule that turns a bullet
+ * (dash, plus, or asterisk) at the start of a textblock into a
+ * bullet list.
+ */
+export declare function bulletListRule(nodeType: NodeType, config?: BulletListInputRuleConfig): import("prosemirror-inputrules").InputRule | null;
+export {};

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

@@ -0,0 +1,38 @@
+import { wrappingInputRule } from '../../../utils/inputrules';
+import { blType, olType } from './utils';
+export const ListsInputRulesExtension = (builder, options) => {
+    builder.addInputRules(({ schema }) => {
+        const rules = [orderedListRule(olType(schema))];
+        if (options.bulletListInputRule !== false) {
+            const blRule = bulletListRule(blType(schema), options.bulletListInputRule);
+            if (blRule)
+                rules.push(blRule);
+        }
+        return { rules };
+    });
+};
+/**
+ * Given a list node type, returns an input rule that turns a number
+ * followed by a dot at the start of a textblock into an ordered list.
+ */
+export function orderedListRule(nodeType) {
+    return wrappingInputRule(/^(\d+)\.\s$/, nodeType, (match) => ({ order: Number(match[1]) }), (match, node) => node.childCount + node.attrs.order === Number(match[1]));
+}
+/**
+ * Given a list node type, returns an input rule that turns a bullet
+ * (dash, plus, or asterisk) at the start of a textblock into a
+ * bullet list.
+ */
+export function bulletListRule(nodeType, config) {
+    const bullets = [];
+    if ((config === null || config === void 0 ? void 0 : config.dash) !== false)
+        bullets.push('-');
+    if ((config === null || config === void 0 ? void 0 : config.plus) !== false)
+        bullets.push('+');
+    if ((config === null || config === void 0 ? void 0 : config.asterisk) !== false)
+        bullets.push('*');
+    if (bullets.length === 0)
+        return null;
+    const regexp = new RegExp(`^\\s*([${bullets.join('')}])\\s$`); // same as /^\s*([-+*])\s$/
+    return wrappingInputRule(regexp, nodeType);
+}

package/build/esm/extensions/markdown/Lists/plugins/MergeListsPlugin.d.ts

@@ -0,0 +1,2 @@
+import { Plugin } from 'prosemirror-state';
+export declare const mergeListsPlugin: () => Plugin<any>;

package/build/esm/extensions/markdown/Lists/plugins/MergeListsPlugin.js

@@ -0,0 +1,28 @@
+import { Plugin } from 'prosemirror-state';
+import { findChildren, hasParentNode } from 'prosemirror-utils';
+import { isListNode } from '../utils';
+export const mergeListsPlugin = () => new Plugin({
+    appendTransaction(trs, oldState, newState) {
+        const docChanged = trs.some((tr) => tr.docChanged);
+        if (!docChanged)
+            return null;
+        const hasParentList = hasParentNode(isListNode)(newState.selection) ||
+            hasParentNode(isListNode)(oldState.selection);
+        if (!hasParentList)
+            return null;
+        const { tr } = newState;
+        const listNodes = findChildren(tr.doc, isListNode, true);
+        mergeAdjacentNodesWithSameType(tr, listNodes);
+        return tr.docChanged ? tr : null;
+    },
+});
+function mergeAdjacentNodesWithSameType(tr, nodes) {
+    for (let i = 0; i < nodes.length - 1; i++) {
+        const current = nodes[i];
+        const next = nodes[i + 1];
+        if (current.node.type === next.node.type &&
+            current.pos + current.node.nodeSize === next.pos) {
+            tr.join(next.pos);
+        }
+    }
+}

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

@@ -0,0 +1,9 @@
+import type { Node, Schema } from 'prosemirror-model';
+import { EditorState } from 'prosemirror-state';
+import { ListNode } from './ListsSpecs';
+export { liType, blType, olType } from './ListsSpecs';
+export declare const findAnyParentList: (schema: Schema) => (selection: import("prosemirror-state").Selection) => import("prosemirror-utils/dist/types").FindResult;
+export declare const isIntoListOfType: (nodeName: ListNode) => (state: EditorState) => boolean;
+export declare const isListNode: ({ type }: Node) => boolean;
+export declare const isListItemNode: (node: Node) => boolean;
+export declare const isListOrItemNode: (node: Node) => boolean;