@gravity-ui/markdown-editor 13.0.0

package/build/cjs/extensions/markdown/Link/PlaceholderWidget/descriptor.js

@@ -0,0 +1,55 @@
+"use strict";
+var _LinkWidgetDescriptor_domElem, _LinkWidgetDescriptor_view, _LinkWidgetDescriptor_getPos;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LinkWidgetDescriptor = exports.addPlaceholder = void 0;
+const tslib_1 = require("tslib");
+const react_1 = tslib_1.__importDefault(require("react"));
+const WidgetDecoration_1 = require("../../../behavior/WidgetDecoration");
+const ReactWidgetDescriptor_1 = require("../../../behavior/WidgetDecoration/ReactWidgetDescriptor");
+const index_1 = require("../../index");
+const widget_1 = require("./widget");
+const addPlaceholder = (tr, deps) => {
+    return new LinkWidgetDescriptor(tr.selection.from, deps).applyTo(tr);
+};
+exports.addPlaceholder = addPlaceholder;
+class LinkWidgetDescriptor extends ReactWidgetDescriptor_1.ReactWidgetDescriptor {
+    constructor(initPos, deps) {
+        super(initPos, 'link-empty');
+        _LinkWidgetDescriptor_domElem.set(this, void 0);
+        _LinkWidgetDescriptor_view.set(this, void 0);
+        _LinkWidgetDescriptor_getPos.set(this, void 0);
+        this.onCancel = () => {
+            if (!tslib_1.__classPrivateFieldGet(this, _LinkWidgetDescriptor_view, "f"))
+                return;
+            tslib_1.__classPrivateFieldGet(this, _LinkWidgetDescriptor_view, "f").dispatch((0, WidgetDecoration_1.removeDecoration)(tslib_1.__classPrivateFieldGet(this, _LinkWidgetDescriptor_view, "f").state.tr, this.id));
+            tslib_1.__classPrivateFieldGet(this, _LinkWidgetDescriptor_view, "f").focus();
+        };
+        this.onSubmit = (params) => {
+            const normalizeResult = this.normalizeUrl(params.url);
+            if (!normalizeResult || !tslib_1.__classPrivateFieldGet(this, _LinkWidgetDescriptor_view, "f") || !tslib_1.__classPrivateFieldGet(this, _LinkWidgetDescriptor_getPos, "f"))
+                return;
+            const { url } = normalizeResult;
+            const text = params.text.trim() || normalizeResult.text;
+            const from = tslib_1.__classPrivateFieldGet(this, _LinkWidgetDescriptor_getPos, "f").call(this);
+            const to = from + text.length;
+            let tr = tslib_1.__classPrivateFieldGet(this, _LinkWidgetDescriptor_view, "f").state.tr;
+            tr = tr.insertText(text, from);
+            tr = tr.addMark(from, to, (0, index_1.linkType)(tslib_1.__classPrivateFieldGet(this, _LinkWidgetDescriptor_view, "f").state.schema).create({ [index_1.LinkAttr.Href]: url }));
+            tr = (0, WidgetDecoration_1.removeDecoration)(tr, this.id);
+            tslib_1.__classPrivateFieldGet(this, _LinkWidgetDescriptor_view, "f").dispatch(tr);
+            tslib_1.__classPrivateFieldGet(this, _LinkWidgetDescriptor_view, "f").focus();
+        };
+        tslib_1.__classPrivateFieldSet(this, _LinkWidgetDescriptor_domElem, document.createElement('span'), "f");
+        this.normalizeUrl = (0, index_1.normalizeUrlFactory)(deps);
+    }
+    getDomElem() {
+        return tslib_1.__classPrivateFieldGet(this, _LinkWidgetDescriptor_domElem, "f");
+    }
+    renderReactElement(view, getPos) {
+        tslib_1.__classPrivateFieldSet(this, _LinkWidgetDescriptor_view, view, "f");
+        tslib_1.__classPrivateFieldSet(this, _LinkWidgetDescriptor_getPos, getPos, "f");
+        return react_1.default.createElement(widget_1.LinkPlaceholderWidget, { onCancel: this.onCancel, onSubmit: this.onSubmit });
+    }
+}
+exports.LinkWidgetDescriptor = LinkWidgetDescriptor;
+_LinkWidgetDescriptor_domElem = new WeakMap(), _LinkWidgetDescriptor_view = new WeakMap(), _LinkWidgetDescriptor_getPos = new WeakMap();

package/build/cjs/extensions/markdown/Link/PlaceholderWidget/widget.css

@@ -0,0 +1,4 @@
+.g-md-link-placeholder-widget {
+  margin: 0 2px;
+  pointer-events: none;
+}

package/build/cjs/extensions/markdown/Link/PlaceholderWidget/widget.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import { LinkFormProps } from '../../../../forms/LinkForm';
+export declare type LinkPlaceholderWidgetProps = {
+    onCancel: () => void;
+    onSubmit: LinkFormProps['onSubmit'];
+};
+export declare const LinkPlaceholderWidget: React.FC<LinkPlaceholderWidgetProps>;

package/build/cjs/extensions/markdown/Link/PlaceholderWidget/widget.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LinkPlaceholderWidget = void 0;
+const tslib_1 = require("tslib");
+const react_1 = tslib_1.__importDefault(require("react"));
+const uikit_1 = require("@gravity-ui/uikit");
+const classname_1 = require("../../../../classname");
+const LinkForm_1 = require("../../../../forms/LinkForm");
+const widgets_1 = require("../../../../i18n/widgets");
+const b = (0, classname_1.cn)('link-placeholder-widget');
+const placement = ['bottom-start', 'top-start', 'bottom-end', 'top-end'];
+const LinkPlaceholderWidget = ({ onCancel, onSubmit, }) => {
+    const divRef = react_1.default.useRef(null);
+    return (react_1.default.createElement(react_1.default.Fragment, null,
+        react_1.default.createElement("span", { ref: divRef, className: b() },
+            react_1.default.createElement("a", { href: "#" }, (0, widgets_1.i18n)('link'))),
+        react_1.default.createElement(uikit_1.Popup, { open: true, onClose: onCancel, anchorRef: divRef, placement: placement },
+            react_1.default.createElement(LinkForm_1.LinkForm, { autoFocus: true, onSubmit: onSubmit, onCancel: onCancel }))));
+};
+exports.LinkPlaceholderWidget = LinkPlaceholderWidget;

package/build/cjs/extensions/markdown/Link/actions/linkActions.d.ts

@@ -0,0 +1,12 @@
+import type { MarkType } from 'prosemirror-model';
+import type { ActionSpec, ExtensionDeps } from '../../../../core';
+export declare type LinkActionParams = {
+    href: string;
+    title?: string;
+    text?: string;
+};
+export declare type LinkActionMeta = {
+    hasSelection: boolean;
+    text(): string;
+};
+export declare function linkCommand(markType: MarkType, deps: ExtensionDeps): ActionSpec;

package/build/cjs/extensions/markdown/Link/actions/linkActions.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.linkCommand = void 0;
+const prosemirror_commands_1 = require("prosemirror-commands");
+const prosemirror_state_1 = require("prosemirror-state");
+const marks_1 = require("../../../../utils/marks");
+const LinkSpecs_1 = require("../LinkSpecs");
+const commands_1 = require("../commands");
+const utils_1 = require("../utils");
+function linkCommand(markType, deps) {
+    const normalizeUrl = (0, utils_1.normalizeUrlFactory)(deps);
+    return {
+        isActive(state) {
+            return Boolean((0, marks_1.isMarkActive)(state, markType));
+        },
+        isEnable(state) {
+            return (0, prosemirror_commands_1.toggleMark)(markType)(state);
+        },
+        run(state, dispatch, view, attrs) {
+            if ((0, commands_1.removeLink)(state, dispatch, view))
+                return;
+            if (!attrs)
+                return;
+            const { text, title } = attrs;
+            const normalizeResult = normalizeUrl(attrs.href);
+            if (normalizeResult) {
+                if (text && state.selection.empty) {
+                    dispatch(state.tr.replaceSelectionWith(state.schema.text(text, [
+                        markType.create({
+                            [LinkSpecs_1.LinkAttr.Href]: normalizeResult.url,
+                            [LinkSpecs_1.LinkAttr.Title]: title,
+                        }),
+                    ]), false));
+                    return;
+                }
+                (0, prosemirror_commands_1.toggleMark)(markType, {
+                    [LinkSpecs_1.LinkAttr.Href]: normalizeResult.url,
+                    [LinkSpecs_1.LinkAttr.Title]: title,
+                })(state, dispatch);
+            }
+        },
+        meta(state) {
+            const { selection } = state;
+            return {
+                hasSelection: !selection.empty && selection instanceof prosemirror_state_1.TextSelection,
+                text() {
+                    const fragment = selection.content().content;
+                    return fragment.textBetween(0, fragment.size);
+                },
+            };
+        },
+    };
+}
+exports.linkCommand = linkCommand;

package/build/cjs/extensions/markdown/Link/actions/linkEnhanceActions.d.ts

@@ -0,0 +1,5 @@
+import { Command } from 'prosemirror-state';
+import { ActionSpec, ExtensionDeps } from '../../../../core';
+export declare const addEmptyLink: Command;
+export declare const addLinkCmd2: (deps: ExtensionDeps) => Command;
+export declare const linkActionSpec2: (deps: ExtensionDeps) => ActionSpec;

package/build/cjs/extensions/markdown/Link/actions/linkEnhanceActions.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.linkActionSpec2 = exports.addLinkCmd2 = exports.addEmptyLink = void 0;
+const prosemirror_commands_1 = require("prosemirror-commands");
+const prosemirror_state_1 = require("prosemirror-state");
+const prosemirror_utils_1 = require("prosemirror-utils");
+const marks_1 = require("../../../../utils/marks");
+const const_1 = require("../../../yfm/ImgSize/const");
+const index_1 = require("../../index");
+const commands_1 = require("../PlaceholderWidget/commands");
+const addEmptyLink = (state, dispatch) => {
+    const linkMarkType = (0, index_1.linkType)(state.schema);
+    const { selection } = state;
+    const { nodeAfter } = selection.$from;
+    if (selection.empty ||
+        ((0, prosemirror_utils_1.isNodeSelection)(selection) && selection.node.type !== (0, index_1.imageType)(state.schema)) ||
+        (!((nodeAfter === null || nodeAfter === void 0 ? void 0 : nodeAfter.isInline) && (nodeAfter === null || nodeAfter === void 0 ? void 0 : nodeAfter.isAtom)) && !(nodeAfter === null || nodeAfter === void 0 ? void 0 : nodeAfter.isText)))
+        return false;
+    const { $from, $to } = selection;
+    // text selection inside one text node
+    if ($from.parent !== $to.parent)
+        return false;
+    let tr = state.tr;
+    (0, prosemirror_commands_1.toggleMark)(linkMarkType, {
+        [index_1.LinkAttr.Href]: '',
+        [index_1.LinkAttr.IsPlaceholder]: true,
+    })(state, (_tr) => {
+        tr = _tr;
+    });
+    tr.scrollIntoView();
+    if (selection instanceof prosemirror_state_1.NodeSelection) {
+        tr.setSelection(prosemirror_state_1.NodeSelection.create(tr.doc, $to.pos - 1));
+        if (selection.node.type === (0, index_1.imageType)(state.schema)) {
+            const meta = { linkAdded: true };
+            tr.setMeta(const_1.imageRendererKey, meta);
+        }
+    }
+    else {
+        const selectedText = state.doc.textBetween($from.pos, $to.pos);
+        const countOfWhitespacesAtEnd = selectedText.length - selectedText.trimEnd().length;
+        tr.setSelection(prosemirror_state_1.TextSelection.create(tr.doc, $to.pos - countOfWhitespacesAtEnd - 1));
+    }
+    dispatch === null || dispatch === void 0 ? void 0 : dispatch(tr);
+    return true;
+};
+exports.addEmptyLink = addEmptyLink;
+const addLinkCmd2 = (deps) => (0, prosemirror_commands_1.chainCommands)(index_1.removeLink, exports.addEmptyLink, (0, commands_1.addLinkPlaceholder)(deps));
+exports.addLinkCmd2 = addLinkCmd2;
+const linkActionSpec2 = (deps) => ({
+    isActive: (state) => Boolean((0, marks_1.isMarkActive)(state, (0, index_1.linkType)(state.schema))),
+    isEnable: (0, exports.addLinkCmd2)(deps),
+    run: (0, exports.addLinkCmd2)(deps),
+});
+exports.linkActionSpec2 = linkActionSpec2;

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

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

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

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeLink = void 0;
+const prosemirror_commands_1 = require("prosemirror-commands");
+const marks_1 = require("../../../utils/marks");
+const _1 = require(".");
+const removeLink = (state, dispatch) => {
+    const linkMarkType = (0, _1.linkType)(state.schema);
+    if ((0, marks_1.isMarkActive)(state, linkMarkType))
+        return (0, prosemirror_commands_1.toggleMark)(linkMarkType)(state, dispatch);
+    return false;
+};
+exports.removeLink = removeLink;

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

@@ -0,0 +1,23 @@
+import type { Action, ExtensionAuto } from '../../../core';
+import { LinkActionMeta, LinkActionParams } from './actions/linkActions';
+export type { LinkActionParams, LinkActionMeta } from './actions/linkActions';
+export { linkCommand } from './actions/linkActions';
+export { normalizeUrlFactory } from './utils';
+export { removeLink } from './commands';
+export { LinkAttr, linkMarkName, linkType } from './LinkSpecs';
+/** @deprecated Use `linkMarkName` instead */
+export declare const link = "link";
+declare const linkAction = "link";
+declare const linkAction2 = "addLink";
+export declare type LinkOptions = {
+    linkKey?: string | null;
+};
+export declare const Link: ExtensionAuto<LinkOptions>;
+declare global {
+    namespace WysiwygEditor {
+        interface Actions {
+            [linkAction]: Action<LinkActionParams, LinkActionMeta>;
+            [linkAction2]: Action;
+        }
+    }
+}

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

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Link = exports.link = exports.linkType = exports.linkMarkName = exports.LinkAttr = exports.removeLink = exports.normalizeUrlFactory = exports.linkCommand = void 0;
+const prosemirror_inputrules_1 = require("prosemirror-inputrules");
+const inputrules_1 = require("../../../utils/inputrules");
+const LinkSpecs_1 = require("./LinkSpecs");
+const linkActions_1 = require("./actions/linkActions");
+const linkEnhanceActions_1 = require("./actions/linkEnhanceActions");
+const paste_plugin_1 = require("./paste-plugin");
+const LinkTooltipPlugin_1 = require("./plugins/LinkTooltipPlugin");
+var linkActions_2 = require("./actions/linkActions");
+Object.defineProperty(exports, "linkCommand", { enumerable: true, get: function () { return linkActions_2.linkCommand; } });
+var utils_1 = require("./utils");
+Object.defineProperty(exports, "normalizeUrlFactory", { enumerable: true, get: function () { return utils_1.normalizeUrlFactory; } });
+var commands_1 = require("./commands");
+Object.defineProperty(exports, "removeLink", { enumerable: true, get: function () { return commands_1.removeLink; } });
+var LinkSpecs_2 = require("./LinkSpecs");
+Object.defineProperty(exports, "LinkAttr", { enumerable: true, get: function () { return LinkSpecs_2.LinkAttr; } });
+Object.defineProperty(exports, "linkMarkName", { enumerable: true, get: function () { return LinkSpecs_2.linkMarkName; } });
+Object.defineProperty(exports, "linkType", { enumerable: true, get: function () { return LinkSpecs_2.linkType; } });
+/** @deprecated Use `linkMarkName` instead */
+exports.link = LinkSpecs_1.linkMarkName;
+const linkAction = 'link';
+const linkAction2 = 'addLink';
+const Link = (builder, opts) => {
+    builder.use(LinkSpecs_1.LinkSpecs);
+    builder.addAction(linkAction2, linkEnhanceActions_1.linkActionSpec2);
+    builder.addPlugin(LinkTooltipPlugin_1.linkTooltipPlugin);
+    if (opts === null || opts === void 0 ? void 0 : opts.linkKey) {
+        const { linkKey } = opts;
+        builder.addKeymap((deps) => ({
+            [linkKey]: (0, linkEnhanceActions_1.addLinkCmd2)(deps),
+        }));
+    }
+    builder
+        .addPlugin(paste_plugin_1.linkPasteEnhance, builder.Priority.High)
+        .addAction(linkAction, (deps) => (0, linkActions_1.linkCommand)((0, LinkSpecs_1.linkType)(deps.schema), deps))
+        .addInputRules(({ schema }) => ({ rules: [linkInputRule((0, LinkSpecs_1.linkType)(schema))] }));
+};
+exports.Link = Link;
+// TODO: think about generalizing with markInputRule
+function linkInputRule(markType) {
+    return new prosemirror_inputrules_1.InputRule(/\[(.+)]\((\S+)\)\s$/, (state, match, start, end) => {
+        if ((0, inputrules_1.hasCodeMark)(state, match, start, end))
+            return null;
+        // handle the rule only if is start of line or there is a space before "open" symbols
+        if (match.index > 0) {
+            const re = match;
+            if (re.input[re.index - 1] !== ' ')
+                return null;
+        }
+        const [okay, alt, href] = match;
+        const { tr } = state;
+        if (okay) {
+            tr.replaceWith(start, end, markType.schema.text(alt)).addMark(start, start + alt.length, markType.create({ href }));
+        }
+        return tr;
+    });
+}

package/build/cjs/extensions/markdown/Link/paste-plugin.d.ts

@@ -0,0 +1,3 @@
+import { Plugin } from 'prosemirror-state';
+import type { ExtensionDeps } from '../../../core';
+export declare function linkPasteEnhance({ markupParser: parser }: ExtensionDeps): Plugin<any>;

package/build/cjs/extensions/markdown/Link/paste-plugin.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.linkPasteEnhance = void 0;
+const prosemirror_state_1 = require("prosemirror-state");
+const selection_1 = require("../../../utils/selection");
+const utils_1 = require("../../behavior/Clipboard/utils");
+const Image_1 = require("../Image");
+const index_1 = require("./index");
+function linkPasteEnhance({ markupParser: parser }) {
+    return new prosemirror_state_1.Plugin({
+        props: {
+            handleDOMEvents: {
+                paste(view, e) {
+                    const { state, dispatch } = view;
+                    const sel = state.selection;
+                    if ((0, selection_1.isTextSelection)(sel) ||
+                        ((0, selection_1.isNodeSelection)(sel) && sel.node.type === (0, Image_1.imageType)(state.schema))) {
+                        const { $from, $to } = sel;
+                        if ($from.pos !== $to.pos && $from.sameParent($to)) {
+                            const url = getUrl(e.clipboardData, parser);
+                            if (url) {
+                                const tr = state.tr.addMark($from.pos, $to.pos, (0, index_1.linkType)(state.schema).create({
+                                    [index_1.LinkAttr.Href]: url,
+                                }));
+                                dispatch(tr.setSelection(prosemirror_state_1.TextSelection.create(tr.doc, $to.pos)));
+                                e.preventDefault();
+                                return true;
+                            }
+                        }
+                    }
+                    return false;
+                },
+            },
+        },
+    });
+}
+exports.linkPasteEnhance = linkPasteEnhance;
+function getUrl(data, parser) {
+    var _a;
+    if (!data || data.types.includes(utils_1.DataTransferType.Yfm))
+        return null;
+    if ((0, utils_1.isIosSafariShare)(data))
+        return data.getData(utils_1.DataTransferType.UriList);
+    // TODO: should we process HTML here?
+    const text = data.getData(utils_1.DataTransferType.Text);
+    const match = parser.matchLinks(text);
+    if (((_a = match === null || match === void 0 ? void 0 : match[0]) === null || _a === void 0 ? void 0 : _a.raw) === text)
+        return match[0].url;
+    return null;
+}

package/build/cjs/extensions/markdown/Link/plugins/LinkTooltipPlugin/TooltipView.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+declare type LinkFormProps = {
+    href: string;
+    autoFocus?: boolean;
+    onChange?: (opts: {
+        href: string;
+    }) => void;
+    onCancel?: () => void;
+};
+export declare const LinkForm: React.NamedExoticComponent<LinkFormProps>;
+export {};

package/build/cjs/extensions/markdown/Link/plugins/LinkTooltipPlugin/TooltipView.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LinkForm = void 0;
+const tslib_1 = require("tslib");
+const react_1 = tslib_1.__importDefault(require("react"));
+const TextInput_1 = require("../../../../../forms/TextInput");
+const UrlInputRow_1 = require("../../../../../forms/UrlInputRow");
+const base_1 = tslib_1.__importDefault(require("../../../../../forms/base"));
+const utils_1 = require("../../../../../forms/utils");
+const forms_1 = require("../../../../../i18n/forms");
+exports.LinkForm = react_1.default.memo(function LinkForm({ href, autoFocus, onChange, onCancel, }) {
+    const [url, setUrl] = react_1.default.useState(href);
+    const handleSubmit = () => {
+        onChange === null || onChange === void 0 ? void 0 : onChange({ href: url });
+    };
+    const inputEnterKeyHandler = (0, utils_1.enterKeyHandler)(handleSubmit);
+    return (react_1.default.createElement(base_1.default.Form, null,
+        react_1.default.createElement(base_1.default.Layout, null,
+            react_1.default.createElement(base_1.default.Row, { label: (0, forms_1.i18n)('common_link'), help: (0, forms_1.i18n)('link_url_help'), control: react_1.default.createElement(UrlInputRow_1.UrlInputRow, { href: url, input: react_1.default.createElement(TextInput_1.TextInputFixed, { size: "s", hasClear: true, view: "normal", value: url, onUpdate: setUrl, placeholder: "https://", autoFocus: autoFocus, onKeyPress: inputEnterKeyHandler }) }) })),
+        react_1.default.createElement(base_1.default.Footer, { onCancel: onCancel, onSubmit: handleSubmit })));
+});

package/build/cjs/extensions/markdown/Link/plugins/LinkTooltipPlugin/index.d.ts

@@ -0,0 +1,3 @@
+import { Plugin } from 'prosemirror-state';
+import { ExtensionDeps } from '../../../../../core';
+export declare const linkTooltipPlugin: (deps: ExtensionDeps) => Plugin<any>;

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

@@ -0,0 +1,201 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.linkTooltipPlugin = void 0;
+const tslib_1 = require("tslib");
+const react_1 = tslib_1.__importDefault(require("react"));
+const uikit_1 = require("@gravity-ui/uikit");
+const prosemirror_keymap_1 = require("prosemirror-keymap");
+const prosemirror_state_1 = require("prosemirror-state");
+const prosemirror_utils_1 = require("prosemirror-utils");
+const prosemirror_view_1 = require("prosemirror-view");
+const ErrorBoundary_1 = require("../../../../../react-utils/ErrorBoundary");
+const marks_1 = require("../../../../../utils/marks");
+const ReactRenderer_1 = require("../../../../behavior/ReactRenderer");
+const index_1 = require("../../../index");
+const TooltipView_1 = require("./TooltipView");
+const className = 'pm-link-focus-deco';
+const placement = ['bottom-start', 'bottom-end', 'top-start', 'top-end'];
+function getTextNode(state) {
+    if (!(state.selection instanceof prosemirror_state_1.TextSelection) ||
+        !state.selection.empty ||
+        !(0, marks_1.isMarkActive)(state, (0, index_1.linkType)(state.schema)))
+        return null;
+    const parent = (0, prosemirror_utils_1.findParentNode)(Boolean)(state.selection);
+    if (!parent) {
+        return null;
+    }
+    const textNodes = (0, prosemirror_utils_1.findChildrenByMark)(parent === null || parent === void 0 ? void 0 : parent.node, (0, index_1.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 });
+}
+const linkTooltipPlugin = (deps) => {
+    let viewTooltip = null;
+    return new prosemirror_state_1.Plugin({
+        view(view) {
+            viewTooltip = new SelectionTooltip(view, deps);
+            return viewTooltip;
+        },
+        props: {
+            handleKeyDown: (0, prosemirror_keymap_1.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 prosemirror_view_1.DecorationSet.empty;
+                const { from, to } = textNode;
+                return prosemirror_view_1.DecorationSet.create(state.doc, [
+                    prosemirror_view_1.Decoration.inline(from, to, {
+                        class: `pm-node-selected ${className}`,
+                    }),
+                ]);
+            },
+        },
+    });
+};
+exports.linkTooltipPlugin = linkTooltipPlugin;
+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 = (0, index_1.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 && (0, marks_1.findMark)(textNode.node, (0, index_1.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 = (0, marks_1.findMark)(textNode.node, (0, index_1.linkType)(state.schema))) === null || _a === void 0 ? void 0 : _a.attrs;
+            if (attrs === null || attrs === void 0 ? void 0 : attrs[index_1.LinkAttr.IsPlaceholder]) {
+                const { from, to } = textNode;
+                let tr = state.tr.removeMark(from, to, (0, index_1.linkType)(state.schema));
+                if (opts === null || opts === void 0 ? void 0 : opts.returnSelection) {
+                    tr = tr.setSelection(prosemirror_state_1.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, (0, index_1.linkType)(view.state.schema).create({ href: url })));
+            setTimeout(this.cancelPopup.bind(this));
+        }
+    }
+    createRenderItem() {
+        return (0, ReactRenderer_1.getReactRendererFromState)(this.view.state).createItem('link-tooltip', () => (react_1.default.createElement(ErrorBoundary_1.ErrorLoggerBoundary, null,
+            react_1.default.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[index_1.LinkAttr.Href];
+    const autoFocus = attrs[index_1.LinkAttr.IsPlaceholder];
+    return (react_1.default.createElement(uikit_1.Popup, { key: href, open: true, anchorRef: { current: domElem }, placement: placement, onEscapeKeyDown: onCancel, onOutsideClick: onOutsideClick },
+        react_1.default.createElement(TooltipView_1.LinkForm, { href: href !== null && href !== void 0 ? href : '', autoFocus: autoFocus, onChange: onChange, onCancel: onCancel })));
+};

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

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeUrlFactory = void 0;
+const isString = (str) => typeof str === 'string';
+const notEmpty = (str) => str.length > 0;
+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;
+};
+exports.normalizeUrlFactory = normalizeUrlFactory;

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

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