@ctzhian/tiptap 1.5.2 → 1.5.4

package/dist/extension/node/TableOfContents/plugin.js

@@ -0,0 +1,58 @@
+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 { Plugin, PluginKey } from '@tiptap/pm/state';
+import { v4 as uuidv4 } from 'uuid';
+export var TableOfContentsPlugin = function TableOfContentsPlugin(_ref) {
+  var getId = _ref.getId,
+    _ref$anchorTypes = _ref.anchorTypes,
+    anchorTypes = _ref$anchorTypes === void 0 ? ['heading'] : _ref$anchorTypes;
+  return new Plugin({
+    key: new PluginKey('tableOfContent'),
+    appendTransaction: function appendTransaction(transactions, oldState, newState) {
+      var _view;
+      // 若处于组合输入，完全避免在此事务中写入 id，交由扩展层异步生成
+      if ((_view = newState.view) !== null && _view !== void 0 && _view.composing || typeof document !== 'undefined' && document.composing || typeof window !== 'undefined' && window.compositionState) {
+        return null;
+      }
+
+      // 检查是否有任何事务包含组合相关的变化
+      var hasCompositionChanges = transactions.some(function (tr) {
+        return tr.getMeta('composition') || tr.getMeta('compositionend') || tr.getMeta('compositionstart');
+      });
+      if (hasCompositionChanges) {
+        return null;
+      }
+      var tr = newState.tr;
+      var modified = false;
+      if (transactions.some(function (transaction) {
+        return transaction.docChanged;
+      }) && !oldState.doc.eq(newState.doc)) {
+        var existingIds = [];
+        newState.doc.descendants(function (node, pos) {
+          var nodeId = node.attrs.id;
+          if (!anchorTypes.includes(node.type.name) || node.textContent.length === 0) {
+            return;
+          }
+          if (nodeId === null || nodeId === undefined || existingIds.includes(nodeId)) {
+            var id = '';
+            if (getId) {
+              id = getId(node.textContent);
+            } else {
+              id = uuidv4();
+            }
+            tr.setNodeMarkup(pos, undefined, _objectSpread(_objectSpread({}, node.attrs), {}, {
+              id: id
+            }));
+            modified = true;
+          }
+          existingIds.push(nodeId);
+        });
+      }
+      return modified ? tr : null;
+    }
+  });
+};

package/dist/extension/node/TableOfContents/type.d.ts

@@ -0,0 +1,45 @@
+import type { Editor } from '@tiptap/core';
+import type { Node } from '@tiptap/pm/model';
+export type GetTableOfContentLevelFunction = (headline: {
+    node: Node;
+    pos: number;
+}, previousItems: TableOfContentDataItem[]) => number;
+export type GetTableOfContentIndexFunction = (headline: {
+    node: Node;
+    pos: number;
+}, previousItems: TableOfContentDataItem[], currentLevel?: number) => number;
+export type TableOfContentsOptions = {
+    getId?: (textContent: string) => string;
+    onUpdate?: (data: TableOfContentData, isCreate?: boolean) => void;
+    getLevel?: GetTableOfContentLevelFunction;
+    getIndex?: GetTableOfContentIndexFunction;
+    scrollParent?: (() => HTMLElement | Window) | HTMLElement | Window;
+    anchorTypes?: Array<string>;
+};
+export type TableOfContentsStorage = {
+    content: TableOfContentData;
+    anchors: Array<HTMLHeadingElement | HTMLElement>;
+    scrollHandler: () => void;
+    scrollPosition: number;
+};
+export type TableOfContentData = Array<TableOfContentDataItem>;
+export type TableOfContentDataItem = {
+    dom: HTMLHeadingElement;
+    editor: Editor;
+    id: string;
+    isActive: boolean;
+    isScrolledOver: boolean;
+    itemIndex: number;
+    level: number;
+    node: Node;
+    originalLevel: number;
+    pos: number;
+    textContent: string;
+};
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        tableOfContents: {
+            updateTableOfContents: () => ReturnType;
+        };
+    }
+}

package/dist/extension/node/TableOfContents/type.js

@@ -0,0 +1 @@
+export {};

package/dist/extension/node/TableOfContents/utils.d.ts

@@ -0,0 +1,6 @@
+import type { GetTableOfContentIndexFunction, GetTableOfContentLevelFunction, TableOfContentDataItem } from './type';
+export declare const getLastHeadingOnLevel: (headings: TableOfContentDataItem[], level: number) => TableOfContentDataItem | undefined;
+export declare const getHeadlineLevel: GetTableOfContentLevelFunction;
+export declare const getLinearIndexes: GetTableOfContentIndexFunction;
+export declare const getHierarchicalIndexes: GetTableOfContentIndexFunction;
+export declare function debounce(func: (...args: any[]) => void, wait: number): (...args: any[]) => void;

package/dist/extension/node/TableOfContents/utils.js

@@ -0,0 +1,70 @@
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+export var getLastHeadingOnLevel = function getLastHeadingOnLevel(headings, level) {
+  var heading = headings.filter(function (currentHeading) {
+    return currentHeading.level === level;
+  }).pop();
+  if (level === 0) {
+    return undefined;
+  }
+  if (!heading) {
+    heading = getLastHeadingOnLevel(headings, level - 1);
+  }
+  return heading;
+};
+export var getHeadlineLevel = function getHeadlineLevel(headline, previousItems) {
+  var level = 1;
+  var previousHeadline = previousItems.at(-1);
+  var highestHeadlineAbove = _toConsumableArray(previousItems).reverse().find(function (h) {
+    return h.originalLevel <= headline.node.attrs.level;
+  });
+  var highestLevelAbove = (highestHeadlineAbove === null || highestHeadlineAbove === void 0 ? void 0 : highestHeadlineAbove.level) || 1;
+  if (headline.node.attrs.level > ((previousHeadline === null || previousHeadline === void 0 ? void 0 : previousHeadline.originalLevel) || 1)) {
+    level = ((previousHeadline === null || previousHeadline === void 0 ? void 0 : previousHeadline.level) || 1) + 1;
+  } else if (headline.node.attrs.level < ((previousHeadline === null || previousHeadline === void 0 ? void 0 : previousHeadline.originalLevel) || 1)) {
+    level = highestLevelAbove;
+  } else {
+    level = (previousHeadline === null || previousHeadline === void 0 ? void 0 : previousHeadline.level) || 1;
+  }
+  return level;
+};
+export var getLinearIndexes = function getLinearIndexes(_headline, previousHeadlines) {
+  var previousHeadline = previousHeadlines.at(-1);
+  if (!previousHeadline) {
+    return 1;
+  }
+  return ((previousHeadline === null || previousHeadline === void 0 ? void 0 : previousHeadline.itemIndex) || 1) + 1;
+};
+export var getHierarchicalIndexes = function getHierarchicalIndexes(headline, previousHeadlines, currentLevel) {
+  var _previousHeadlinesOnL;
+  var level = currentLevel || headline.node.attrs.level || 1;
+  var itemIndex = 1;
+  var previousHeadlinesOnLevelOrBelow = previousHeadlines.filter(function (h) {
+    return h.level <= level;
+  });
+  if (((_previousHeadlinesOnL = previousHeadlinesOnLevelOrBelow.at(-1)) === null || _previousHeadlinesOnL === void 0 ? void 0 : _previousHeadlinesOnL.level) === level) {
+    var _previousHeadlinesOnL2;
+    itemIndex = (((_previousHeadlinesOnL2 = previousHeadlinesOnLevelOrBelow.at(-1)) === null || _previousHeadlinesOnL2 === void 0 ? void 0 : _previousHeadlinesOnL2.itemIndex) || 1) + 1;
+  } else {
+    itemIndex = 1;
+  }
+  return itemIndex;
+};
+export function debounce(func, wait) {
+  var timeout = null;
+  return function () {
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    if (timeout) {
+      clearTimeout(timeout);
+    }
+    timeout = setTimeout(function () {
+      func.apply(void 0, args);
+    }, wait);
+  };
+}

package/dist/extension/node/UploadProgress.d.ts

@@ -0,0 +1,21 @@
+import { Node } from '@tiptap/core';
+import { UploadProgressAttributes } from '../component/UploadProgress';
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        uploadProgress: {
+            /**
+             * Insert upload progress indicator
+             */
+            setUploadProgress: (options: UploadProgressAttributes) => ReturnType;
+            /**
+             * Update upload progress
+             */
+            updateUploadProgress: (tempId: string, progress: number) => ReturnType;
+            /**
+             * Remove upload progress indicator
+             */
+            removeUploadProgress: (tempId: string) => ReturnType;
+        };
+    }
+}
+export declare const UploadProgressExtension: Node<any, any>;

package/dist/extension/node/UploadProgress.js

@@ -0,0 +1,135 @@
+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 { mergeAttributes, Node } from '@tiptap/core';
+import { ReactNodeViewRenderer } from '@tiptap/react';
+import UploadProgressView from "../component/UploadProgress";
+export var UploadProgressExtension = Node.create({
+  name: 'uploadProgress',
+  group: 'block',
+  atom: true,
+  selectable: false,
+  draggable: false,
+  addAttributes: function addAttributes() {
+    return {
+      fileName: {
+        default: '',
+        parseHTML: function parseHTML(element) {
+          return element.getAttribute('data-file-name');
+        },
+        renderHTML: function renderHTML(attributes) {
+          if (!attributes.fileName) {
+            return {};
+          }
+          return {
+            'data-file-name': attributes.fileName
+          };
+        }
+      },
+      fileType: {
+        default: 'other',
+        parseHTML: function parseHTML(element) {
+          return element.getAttribute('data-file-type');
+        },
+        renderHTML: function renderHTML(attributes) {
+          if (!attributes.fileType) {
+            return {};
+          }
+          return {
+            'data-file-type': attributes.fileType
+          };
+        }
+      },
+      progress: {
+        default: 0,
+        parseHTML: function parseHTML(element) {
+          return parseFloat(element.getAttribute('data-progress') || '0');
+        },
+        renderHTML: function renderHTML(attributes) {
+          return {
+            'data-progress': attributes.progress
+          };
+        }
+      },
+      tempId: {
+        default: '',
+        parseHTML: function parseHTML(element) {
+          return element.getAttribute('data-temp-id');
+        },
+        renderHTML: function renderHTML(attributes) {
+          if (!attributes.tempId) {
+            return {};
+          }
+          return {
+            'data-temp-id': attributes.tempId
+          };
+        }
+      }
+    };
+  },
+  parseHTML: function parseHTML() {
+    return [{
+      tag: 'div[data-type="upload-progress"]'
+    }];
+  },
+  renderHTML: function renderHTML(_ref) {
+    var HTMLAttributes = _ref.HTMLAttributes;
+    return ['div', mergeAttributes({
+      'data-type': 'upload-progress'
+    }, HTMLAttributes)];
+  },
+  addCommands: function addCommands() {
+    var _this = this;
+    return {
+      setUploadProgress: function setUploadProgress(options) {
+        return function (_ref2) {
+          var commands = _ref2.commands;
+          return commands.insertContent({
+            type: _this.name,
+            attrs: options
+          });
+        };
+      },
+      updateUploadProgress: function updateUploadProgress(tempId, progress) {
+        return function (_ref3) {
+          var tr = _ref3.tr,
+            state = _ref3.state;
+          var doc = state.doc;
+          var updated = false;
+          doc.descendants(function (node, pos) {
+            if (node.type.name === _this.name && node.attrs.tempId === tempId) {
+              tr.setNodeMarkup(pos, undefined, _objectSpread(_objectSpread({}, node.attrs), {}, {
+                progress: progress
+              }));
+              updated = true;
+              return false; // 停止遍历
+            }
+          });
+          return updated;
+        };
+      },
+      removeUploadProgress: function removeUploadProgress(tempId) {
+        return function (_ref4) {
+          var tr = _ref4.tr,
+            state = _ref4.state;
+          var doc = state.doc;
+          var removed = false;
+          doc.descendants(function (node, pos) {
+            if (node.type.name === _this.name && node.attrs.tempId === tempId) {
+              tr.delete(pos, pos + node.nodeSize);
+              removed = true;
+              return false; // 停止遍历
+            }
+          });
+          return removed;
+        };
+      }
+    };
+  },
+  addNodeView: function addNodeView() {
+    return ReactNodeViewRenderer(UploadProgressView);
+  }
+});

package/dist/extension/node/VerticalAlign.d.ts

@@ -0,0 +1,49 @@
+import { Extension } from '@tiptap/core';
+export interface VerticalAlignOptions {
+    /**
+     * The types where the vertical align attribute can be applied.
+     * @default ['textStyle']
+     * @example ['textStyle']
+     */
+    types: string[];
+    /**
+     * The alignments which are allowed.
+     * @default ['top', 'middle', 'bottom']
+     */
+    alignments: string[];
+    /**
+     * The default alignment.
+     * @default null
+     */
+    defaultAlignment: string | null;
+}
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        verticalAlign: {
+            /**
+             * Set the vertical align attribute
+             * @param alignment The alignment
+             * @example editor.commands.setVerticalAlign('top')
+             */
+            setVerticalAlign: (alignment: string) => ReturnType;
+            /**
+             * Unset the vertical align attribute
+             * @example editor.commands.unsetVerticalAlign()
+             */
+            unsetVerticalAlign: () => ReturnType;
+            /**
+             * Toggle the vertical align attribute
+             * @param alignment The alignment
+             * @example editor.commands.toggleVerticalAlign('middle')
+             */
+            toggleVerticalAlign: (alignment: string) => ReturnType;
+        };
+    }
+}
+declare module '@tiptap/extension-text-style' {
+    interface TextStyleAttributes {
+        verticalAlign?: string | null;
+    }
+}
+export declare const VerticalAlign: Extension<VerticalAlignOptions, any>;
+export default VerticalAlign;

package/dist/extension/node/VerticalAlign.js

@@ -0,0 +1,88 @@
+import { Extension } from '@tiptap/core';
+export var VerticalAlign = Extension.create({
+  name: 'verticalAlign',
+  addOptions: function addOptions() {
+    return {
+      types: ['textStyle'],
+      alignments: ['top', 'middle', 'bottom'],
+      defaultAlignment: null
+    };
+  },
+  addGlobalAttributes: function addGlobalAttributes() {
+    var _this = this;
+    return [{
+      types: this.options.types,
+      attributes: {
+        verticalAlign: {
+          default: this.options.defaultAlignment,
+          parseHTML: function parseHTML(element) {
+            var alignment = element.style.verticalAlign;
+            return _this.options.alignments.includes(alignment) ? alignment : _this.options.defaultAlignment;
+          },
+          renderHTML: function renderHTML(attributes) {
+            if (!attributes.verticalAlign) {
+              return {};
+            }
+            return {
+              style: "vertical-align: ".concat(attributes.verticalAlign)
+            };
+          }
+        }
+      }
+    }];
+  },
+  addCommands: function addCommands() {
+    var _this2 = this;
+    return {
+      setVerticalAlign: function setVerticalAlign(alignment) {
+        return function (_ref) {
+          var commands = _ref.commands;
+          if (!_this2.options.alignments.includes(alignment)) {
+            return false;
+          }
+          return commands.toggleTextStyle({
+            verticalAlign: alignment
+          });
+        };
+      },
+      unsetVerticalAlign: function unsetVerticalAlign() {
+        return function (_ref2) {
+          var commands = _ref2.commands;
+          return commands.toggleTextStyle({
+            verticalAlign: null
+          });
+        };
+      },
+      toggleVerticalAlign: function toggleVerticalAlign(alignment) {
+        return function (_ref3) {
+          var editor = _ref3.editor,
+            commands = _ref3.commands;
+          if (!_this2.options.alignments.includes(alignment)) {
+            return false;
+          }
+          if (editor.isActive('textStyle', {
+            verticalAlign: alignment
+          })) {
+            return commands.unsetVerticalAlign();
+          }
+          return commands.setVerticalAlign(alignment);
+        };
+      }
+    };
+  },
+  addKeyboardShortcuts: function addKeyboardShortcuts() {
+    var _this3 = this;
+    return {
+      'Mod-Alt-t': function ModAltT() {
+        return _this3.editor.commands.setVerticalAlign('top');
+      },
+      'Mod-Alt-m': function ModAltM() {
+        return _this3.editor.commands.setVerticalAlign('middle');
+      },
+      'Mod-Alt-b': function ModAltB() {
+        return _this3.editor.commands.setVerticalAlign('bottom');
+      }
+    };
+  }
+});
+export default VerticalAlign;

package/dist/extension/node/Video.d.ts

@@ -0,0 +1,23 @@
+import { EditorFnProps } from "../../type";
+import { Node } from '@tiptap/core';
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        video: {
+            /**
+             * Insert a video
+             */
+            setVideo: (options: {
+                src: string;
+                width?: number;
+                controls?: boolean;
+                autoplay?: boolean;
+                loop?: boolean;
+                muted?: boolean;
+                poster?: string;
+            }) => ReturnType;
+        };
+    }
+}
+export type VideoExtensionProps = EditorFnProps;
+export declare const VideoExtension: (props: VideoExtensionProps) => Node<any, any>;
+export default VideoExtension;