@ctzhian/tiptap 2.13.7-beta.0 → 3.0.0

package/dist/editor-core/extensions/node/Link/index.js

@@ -0,0 +1,568 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import { getLinkAttributesWithSelectedText, getLinkTitle } from "../../../../utils";
+import { mergeAttributes, Node, nodePasteRule } from '@tiptap/core';
+import { Plugin, PluginKey } from '@tiptap/pm/state';
+import { ReactNodeViewRenderer } from '@tiptap/react';
+import { find as _find, registerCustomProtocol, reset } from 'linkifyjs';
+import LinkViewWrapper from "../../component/Link";
+import { autolink } from "./helpers/autolink";
+import { clickHandler } from "./helpers/clickHandler";
+import { pasteHandler } from "./helpers/pasteHandler";
+import { renderMarkdownLink } from "../resource-shared";
+import { UNICODE_WHITESPACE_REGEX_GLOBAL } from "./helpers/whitespace";
+
+// export const pasteRegex =
+//   /https?:\/\/(?:www\.)?[-a-zA-Z0-9@:%._+~#=]{1,256}\.[a-zA-Z]{2,}\b(?:[-a-zA-Z0-9@:%._+~#=?!&/]*)(?:[-a-zA-Z0-9@:%._+~#=?!&/]*)/gi
+
+/**
+ * @deprecated The default behavior is now to open links when the editor is not editable.
+ */
+
+function _isAllowedUri(uri, protocols) {
+  var allowedProtocols = ['http', 'https', 'ftp', 'ftps', 'mailto', 'tel', 'callto', 'sms', 'cid', 'xmpp'];
+  if (protocols) {
+    protocols.forEach(function (protocol) {
+      var nextProtocol = typeof protocol === 'string' ? protocol : protocol.scheme;
+      if (nextProtocol) {
+        allowedProtocols.push(nextProtocol);
+      }
+    });
+  }
+  return !uri || uri.replace(UNICODE_WHITESPACE_REGEX_GLOBAL, '').match(new RegExp( // eslint-disable-next-line no-useless-escape
+  "^(?:(?:".concat(allowedProtocols.join('|'), "):|[^a-z]|[a-z0-9+.-]+(?:[^a-z+.-:]|$))"), 'i'));
+}
+export { _isAllowedUri as isAllowedUri };
+export var InlineLinkExtension = Node.create({
+  name: 'inlineLink',
+  group: 'inline',
+  inline: true,
+  atom: true,
+  draggable: true,
+  selectable: true,
+  // This node started from the upstream link implementation, but it now carries
+  // product-specific display modes (text/icon/block) and should not be treated
+  // as a drop-in replaceable workaround during upgrades.
+  onCreate: function onCreate() {
+    if (this.options.validate && !this.options.shouldAutoLink) {
+      this.options.shouldAutoLink = this.options.validate;
+      console.warn('The `validate` option is deprecated. Rename to the `shouldAutoLink` option instead.');
+    }
+    this.options.protocols.forEach(function (protocol) {
+      if (typeof protocol === 'string') {
+        registerCustomProtocol(protocol);
+        return;
+      }
+      registerCustomProtocol(protocol.scheme, protocol.optionalSlashes);
+    });
+  },
+  onDestroy: function onDestroy() {
+    reset();
+  },
+  addOptions: function addOptions() {
+    return {
+      autolink: false,
+      linkOnPaste: false,
+      protocols: [],
+      defaultProtocol: 'http',
+      openOnClick: true,
+      enableClickSelection: false,
+      HTMLAttributes: {
+        target: '_blank',
+        class: null,
+        type: 'icon',
+        rel: null,
+        title: null,
+        download: null
+      },
+      isAllowedUri: function isAllowedUri(url, ctx) {
+        return !!_isAllowedUri(url, ctx.protocols);
+      },
+      validate: function validate(url) {
+        return !!url;
+      },
+      shouldAutoLink: function shouldAutoLink(url) {
+        return !!url;
+      }
+    };
+  },
+  addAttributes: function addAttributes() {
+    return {
+      href: {
+        default: null,
+        parseHTML: function parseHTML(element) {
+          return element.getAttribute('href');
+        },
+        renderHTML: function renderHTML(attributes) {
+          return {
+            href: attributes.href
+          };
+        }
+      },
+      target: {
+        default: this.options.HTMLAttributes.target,
+        parseHTML: function parseHTML(element) {
+          return element.getAttribute('target');
+        },
+        renderHTML: function renderHTML(attributes) {
+          return {
+            target: attributes.target
+          };
+        }
+      },
+      rel: {
+        default: this.options.HTMLAttributes.rel,
+        parseHTML: function parseHTML(element) {
+          return element.getAttribute('rel');
+        },
+        renderHTML: function renderHTML(attributes) {
+          return {
+            rel: attributes.rel
+          };
+        }
+      },
+      class: {
+        default: this.options.HTMLAttributes.class,
+        parseHTML: function parseHTML(element) {
+          return element.getAttribute('class');
+        },
+        renderHTML: function renderHTML(attributes) {
+          return {
+            class: attributes.class
+          };
+        }
+      },
+      title: {
+        default: this.options.HTMLAttributes.title,
+        parseHTML: function parseHTML(element) {
+          return element.textContent || element.getAttribute('title');
+        },
+        renderHTML: function renderHTML(attributes) {
+          return {
+            'title': attributes.title
+          };
+        }
+      },
+      type: {
+        default: this.options.HTMLAttributes.type,
+        parseHTML: function parseHTML(element) {
+          return element.getAttribute('type') || 'icon';
+        },
+        renderHTML: function renderHTML(attributes) {
+          return {
+            'type': attributes.type
+          };
+        }
+      },
+      download: {
+        default: null,
+        parseHTML: function parseHTML(element) {
+          return element.getAttribute('download');
+        },
+        renderHTML: function renderHTML(attributes) {
+          if (!attributes.download) {
+            return {};
+          }
+          return {
+            download: attributes.download
+          };
+        }
+      }
+    };
+  },
+  parseHTML: function parseHTML() {
+    var _this = this;
+    return [{
+      tag: 'a',
+      getAttrs: function getAttrs(dom) {
+        var element = dom;
+        var href = element.getAttribute('href');
+        var dataType = element.getAttribute('type');
+        var download = element.getAttribute('download');
+
+        // 如果 <a> 标签内部包含图片，则视为"图片链接"，不解析为 inlineLink，
+        // 让内部的 <img> 节点按普通图片逻辑处理，避免丢失图片和文本。
+        var hasImageChild = Array.from(element.childNodes).some(function (node) {
+          return node.nodeType === 1 && node.tagName.toLowerCase() === 'img';
+        });
+        if (hasImageChild) {
+          return false;
+        }
+
+        // 如果存在 download 属性，认为是附件，不解析为链接
+        if (download !== null) {
+          return false;
+        }
+        if (dataType === 'block') {
+          return false;
+        }
+        if (!href || !href.trim()) {
+          return false;
+        }
+        if (href && !_this.options.isAllowedUri(href, {
+          defaultValidate: function defaultValidate(url) {
+            return !!_isAllowedUri(url, _this.options.protocols);
+          },
+          protocols: _this.options.protocols,
+          defaultProtocol: _this.options.defaultProtocol
+        })) {
+          return false;
+        }
+        return {
+          href: href,
+          target: element.getAttribute('target') || _this.options.HTMLAttributes.target,
+          class: element.getAttribute('class') || _this.options.HTMLAttributes.class,
+          rel: element.getAttribute('rel'),
+          title: element.textContent || element.getAttribute('title'),
+          type: element.getAttribute('type') || 'icon',
+          download: element.getAttribute('download')
+        };
+      }
+    }];
+  },
+  renderHTML: function renderHTML(_ref) {
+    var _this2 = this;
+    var HTMLAttributes = _ref.HTMLAttributes;
+    var title = HTMLAttributes.title || HTMLAttributes.href && getLinkTitle(HTMLAttributes.href);
+    if (!this.options.isAllowedUri(HTMLAttributes.href, {
+      defaultValidate: function defaultValidate(href) {
+        return !!_isAllowedUri(href, _this2.options.protocols);
+      },
+      protocols: this.options.protocols,
+      defaultProtocol: this.options.defaultProtocol
+    })) {
+      return ['a', mergeAttributes(this.options.HTMLAttributes, _objectSpread(_objectSpread({}, HTMLAttributes), {}, {
+        href: ''
+      })), title];
+    }
+    return ['a', mergeAttributes(this.options.HTMLAttributes, HTMLAttributes), title];
+  },
+  addCommands: function addCommands() {
+    var _this3 = this;
+    return {
+      setInlineLink: function setInlineLink(options) {
+        return function (_ref2) {
+          var commands = _ref2.commands;
+          return commands.insertContent({
+            type: _this3.name,
+            attrs: options
+          });
+        };
+      },
+      toggleInlineLink: function toggleInlineLink(options) {
+        return function (_ref3) {
+          var chain = _ref3.chain;
+          return chain().toggleNode(_this3.name, 'a', options).run();
+        };
+      },
+      unsetInlineLink: function unsetInlineLink() {
+        return function (_ref4) {
+          var chain = _ref4.chain;
+          return chain().deleteNode(_this3.name).run();
+        };
+      }
+    };
+  },
+  addPasteRules: function addPasteRules() {
+    var _this4 = this;
+    return [nodePasteRule({
+      find: function find(text) {
+        var foundLinks = [];
+        if (text) {
+          var _this4$options = _this4.options,
+            protocols = _this4$options.protocols,
+            defaultProtocol = _this4$options.defaultProtocol;
+          var links = _find(text).filter(function (item) {
+            return item.isLink && _this4.options.isAllowedUri(item.value, {
+              defaultValidate: function defaultValidate(href) {
+                return !!_isAllowedUri(href, protocols);
+              },
+              protocols: protocols,
+              defaultProtocol: defaultProtocol
+            });
+          });
+          if (links.length) {
+            links.forEach(function (link) {
+              return foundLinks.push({
+                text: link.value,
+                data: {
+                  href: link.href
+                },
+                index: link.start
+              });
+            });
+          }
+        }
+        return foundLinks;
+      },
+      type: this.type,
+      getAttributes: function getAttributes(match) {
+        var _match$data;
+        return {
+          href: (_match$data = match.data) === null || _match$data === void 0 ? void 0 : _match$data.href
+        };
+      }
+    })];
+  },
+  addProseMirrorPlugins: function addProseMirrorPlugins() {
+    var _this5 = this;
+    var plugins = [new Plugin({
+      key: new PluginKey('linkDownloadHandler'),
+      props: {
+        handleDOMEvents: {
+          click: function click(view, event) {
+            var target = event.target;
+            var link = target.closest('a[download]');
+            if (link) {
+              var downloadAttr = link.getAttribute('download');
+              var href = link.getAttribute('href');
+              if (href && downloadAttr !== null) {
+                event.preventDefault();
+                var downloadLink = document.createElement('a');
+                downloadLink.href = href;
+                downloadLink.download = downloadAttr === '' ? href.split('/').pop() || 'download' : downloadAttr;
+                document.body.appendChild(downloadLink);
+                downloadLink.click();
+                document.body.removeChild(downloadLink);
+                return true;
+              }
+            }
+            return false;
+          }
+        }
+      }
+    })];
+    var _this$options = this.options,
+      protocols = _this$options.protocols,
+      defaultProtocol = _this$options.defaultProtocol;
+    if (this.options.autolink) {
+      plugins.push(autolink({
+        type: this.type,
+        defaultProtocol: this.options.defaultProtocol,
+        validate: function validate(url) {
+          return _this5.options.isAllowedUri(url, {
+            defaultValidate: function defaultValidate(href) {
+              return !!_isAllowedUri(href, protocols);
+            },
+            protocols: protocols,
+            defaultProtocol: defaultProtocol
+          });
+        },
+        shouldAutoLink: this.options.shouldAutoLink
+      }));
+    }
+    if (this.options.openOnClick === true) {
+      plugins.push(clickHandler({
+        type: this.type,
+        editor: this.editor,
+        enableClickSelection: this.options.enableClickSelection
+      }));
+    }
+    if (this.options.linkOnPaste) {
+      plugins.push(pasteHandler({
+        editor: this.editor,
+        defaultProtocol: this.options.defaultProtocol,
+        type: this.type
+      }));
+    }
+    return plugins;
+  },
+  addKeyboardShortcuts: function addKeyboardShortcuts() {
+    var _this6 = this;
+    return {
+      'Mod-1': function Mod1() {
+        var linkAttributes = getLinkAttributesWithSelectedText(_this6.editor);
+        return _this6.editor.commands.setInlineLink(_objectSpread({
+          href: '',
+          type: 'icon'
+        }, linkAttributes));
+      }
+    };
+  },
+  markdownTokenName: 'link',
+  parseMarkdown: function parseMarkdown(token, helpers) {
+    return helpers.createNode('inlineLink', {
+      href: token.href || '',
+      title: token.text || '',
+      type: 'icon',
+      target: '_blank'
+    }, [helpers.createTextNode(token.text || '')]);
+  },
+  renderMarkdown: function renderMarkdown(node) {
+    // Local `title` stores display text for the custom link node, not the
+    // upstream HTML title attribute semantics introduced later in Tiptap.
+    return renderMarkdownLink(node.attrs || {});
+  },
+  addNodeView: function addNodeView() {
+    return ReactNodeViewRenderer(LinkViewWrapper);
+  }
+});
+export var BlockLinkExtension = Node.create({
+  name: 'blockLink',
+  group: 'block',
+  atom: true,
+  draggable: true,
+  selectable: true,
+  addOptions: function addOptions() {
+    return {
+      HTMLAttributes: {
+        target: '_blank',
+        class: null,
+        type: 'block',
+        download: null
+      }
+    };
+  },
+  addAttributes: function addAttributes() {
+    return {
+      href: {
+        default: null,
+        parseHTML: function parseHTML(element) {
+          return element.getAttribute('href');
+        },
+        renderHTML: function renderHTML(attributes) {
+          if (!attributes.href) {
+            return {};
+          }
+          return {
+            href: attributes.href
+          };
+        }
+      },
+      target: {
+        default: this.options.HTMLAttributes.target,
+        parseHTML: function parseHTML(element) {
+          return element.getAttribute('target');
+        },
+        renderHTML: function renderHTML(attributes) {
+          if (!attributes.target) {
+            return {};
+          }
+          return {
+            target: attributes.target
+          };
+        }
+      },
+      class: {
+        default: this.options.HTMLAttributes.class,
+        parseHTML: function parseHTML(element) {
+          return element.getAttribute('class');
+        },
+        renderHTML: function renderHTML(attributes) {
+          if (!attributes.class) {
+            return {};
+          }
+          return {
+            class: attributes.class
+          };
+        }
+      },
+      title: {
+        default: null,
+        parseHTML: function parseHTML(element) {
+          return element.textContent || element.getAttribute('title');
+        },
+        renderHTML: function renderHTML(attributes) {
+          if (!attributes.title) {
+            return {};
+          }
+          return {
+            title: attributes.title
+          };
+        }
+      },
+      rel: {
+        default: null,
+        parseHTML: function parseHTML(element) {
+          return element.getAttribute('rel');
+        },
+        renderHTML: function renderHTML(attributes) {
+          if (!attributes.rel) {
+            return {};
+          }
+          return {
+            rel: attributes.rel
+          };
+        }
+      },
+      type: {
+        default: 'block',
+        parseHTML: function parseHTML(element) {
+          return element.getAttribute('type') || 'block';
+        },
+        renderHTML: function renderHTML(attributes) {
+          return {
+            'type': attributes.type
+          };
+        }
+      },
+      download: {
+        default: null,
+        parseHTML: function parseHTML(element) {
+          return element.getAttribute('download');
+        },
+        renderHTML: function renderHTML(attributes) {
+          if (!attributes.download) {
+            return {};
+          }
+          return {
+            download: attributes.download
+          };
+        }
+      }
+    };
+  },
+  parseHTML: function parseHTML() {
+    var _this7 = this;
+    return [{
+      tag: 'a[type="block"]',
+      getAttrs: function getAttrs(dom) {
+        if (!(dom instanceof HTMLElement)) return false;
+        var download = dom.getAttribute('download');
+
+        // 如果存在 download 属性，认为是附件，不解析为链接
+        if (download !== null) {
+          return false;
+        }
+        return {
+          href: dom.getAttribute('href') || '',
+          target: dom.getAttribute('target') || _this7.options.HTMLAttributes.target,
+          class: dom.getAttribute('class') || _this7.options.HTMLAttributes.class,
+          title: dom.textContent || dom.getAttribute('title') || '',
+          rel: dom.getAttribute('rel') || '',
+          type: dom.getAttribute('type') || 'block',
+          download: dom.getAttribute('download')
+        };
+      }
+    }];
+  },
+  renderHTML: function renderHTML(_ref5) {
+    var HTMLAttributes = _ref5.HTMLAttributes;
+    var title = HTMLAttributes.title || HTMLAttributes.href && getLinkTitle(HTMLAttributes.href);
+    return ['a', mergeAttributes(this.options.HTMLAttributes, HTMLAttributes), title];
+  },
+  renderMarkdown: function renderMarkdown(node) {
+    return renderMarkdownLink(node.attrs || {});
+  },
+  addCommands: function addCommands() {
+    var _this8 = this;
+    return {
+      setBlockLink: function setBlockLink(options) {
+        return function (_ref6) {
+          var commands = _ref6.commands;
+          return commands.insertContent({
+            type: _this8.name,
+            attrs: options
+          });
+        };
+      }
+    };
+  },
+  addNodeView: function addNodeView() {
+    return ReactNodeViewRenderer(LinkViewWrapper);
+  }
+});

package/dist/editor-core/extensions/node/ListKit.js

@@ -0,0 +1,18 @@
+import { ListKit } from '@tiptap/extension-list';
+import { LIST_HTML_ATTRIBUTES } from "./list-shared";
+export var ListExtension = ListKit.configure({
+  orderedList: {
+    HTMLAttributes: LIST_HTML_ATTRIBUTES.orderedList
+  },
+  bulletList: {
+    HTMLAttributes: LIST_HTML_ATTRIBUTES.bulletList
+  },
+  taskList: {
+    HTMLAttributes: LIST_HTML_ATTRIBUTES.taskList
+  },
+  taskItem: {
+    nested: true,
+    HTMLAttributes: LIST_HTML_ATTRIBUTES.taskItem
+  }
+});
+export default ListExtension;

package/dist/editor-core/extensions/node/Mathematics.d.ts

@@ -0,0 +1,27 @@
+import { EditorFnProps } from "../../../types";
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        CustomInlineMath: {
+            /**
+             * Insert a inline math node with LaTeX string.
+             * @param options - Options for inserting inline math.
+             * @returns ReturnType
+             */
+            setInlineMath: (options: {
+                latex: string;
+            }) => ReturnType;
+        };
+        CustomBlockMath: {
+            /**
+             * Insert a block math node with LaTeX string.
+             * @param options - Options for inserting block math.
+             * @returns ReturnType
+             */
+            setBlockMath: (options: {
+                latex: string;
+            }) => ReturnType;
+        };
+    }
+}
+export declare const CustomInlineMathExtension: (options: EditorFnProps) => import("@tiptap/core").Node<import("@tiptap/extension-mathematics").InlineMathOptions, any>;
+export declare const CustomBlockMathExtension: (options: EditorFnProps) => import("@tiptap/core").Node<import("@tiptap/extension-mathematics").BlockMathOptions, any>;

package/dist/editor-core/extensions/node/Mathematics.js

@@ -0,0 +1,58 @@
+import { BlockMath, InlineMath } from "@tiptap/extension-mathematics";
+import { createBlockMathNodeView, createInlineMathNodeView, createMathInsertCommand, createMathKeyboardShortcut } from "./mathematics-shared";
+var CustomInlineMath = function CustomInlineMath(options) {
+  return InlineMath.extend({
+    addKeyboardShortcuts: function addKeyboardShortcuts() {
+      return {
+        'Mod-6': createMathKeyboardShortcut(this.name)()
+      };
+    },
+    addCommands: function addCommands() {
+      var _this = this;
+      return {
+        setInlineMath: function setInlineMath(options) {
+          return createMathInsertCommand(_this.name)(options);
+        }
+      };
+    },
+    addNodeView: function addNodeView() {
+      return createInlineMathNodeView(options);
+    }
+  });
+};
+var CustomBlockMath = function CustomBlockMath(options) {
+  return BlockMath.extend({
+    addKeyboardShortcuts: function addKeyboardShortcuts() {
+      return {
+        'Mod-7': createMathKeyboardShortcut(this.name)()
+      };
+    },
+    addCommands: function addCommands() {
+      var _this2 = this;
+      return {
+        setBlockMath: function setBlockMath(options) {
+          return createMathInsertCommand(_this2.name)(options);
+        }
+      };
+    },
+    addNodeView: function addNodeView() {
+      return createBlockMathNodeView(options);
+    }
+  });
+};
+export var CustomInlineMathExtension = function CustomInlineMathExtension(options) {
+  return CustomInlineMath(options).configure({
+    katexOptions: {
+      throwOnError: false,
+      displayMode: false
+    }
+  });
+};
+export var CustomBlockMathExtension = function CustomBlockMathExtension(options) {
+  return CustomBlockMath(options).configure({
+    katexOptions: {
+      throwOnError: false,
+      displayMode: true
+    }
+  });
+};

package/dist/editor-core/extensions/node/Mention.d.ts

@@ -0,0 +1,2 @@
+import { MentionExtensionProps } from "../../../types";
+export declare const MentionExtension: (props: MentionExtensionProps) => import("@tiptap/core").Node<import("@tiptap/extension-mention").MentionOptions<any, import("@tiptap/extension-mention").MentionNodeAttrs>, any>;