@ctzhian/tiptap 1.12.24 → 1.13.1

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

@@ -1,58 +0,0 @@
-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

@@ -1,45 +0,0 @@
-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

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

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

@@ -1,6 +0,0 @@
-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

@@ -1,70 +0,0 @@
-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/util/migrateMathStrings.d.ts

@@ -1,73 +0,0 @@
-import type { Editor } from '@tiptap/core';
-import type { Transaction } from '@tiptap/pm/state';
-/**
- * Regular expression to match LaTeX math strings wrapped in single dollar signs.
- * This should not catch dollar signs which are not part of a math expression,
- * like those used for currency or other purposes.
- * It ensures that the dollar signs are not preceded or followed by digits,
- * allowing for proper identification of inline math expressions.
- *
- * - `$x^2 + y^2 = z^2$` will match
- * - `This is $inline math$ in text.` will match
- * - `This is $100$ dollars.` will not match (as it is not a math expression)
- * - `This is $x^2 + y^2 = z^2$ and $100$ dollars.` will match both math expressions
- * - `$$\frac{a}{b}$$` will NOT match (block math should be handled separately)
- */
-export declare const mathMigrationRegex: RegExp;
-/**
- * Regular expression to match LaTeX math strings wrapped in double dollar signs.
- * This matches block-level math expressions that should be displayed on their own line.
- *
- * - `$$\frac{a}{b}$$` will match
- * - `$$\int_{-\infty}^{\infty} e^{-x^2} dx = \sqrt{\pi}$$` will match
- * - `$$100$$ dollars` will not match (as it is not a math expression)
- */
-export declare const blockMathMigrationRegex: RegExp;
-/**
- * Alternative approach: First find all math patterns, then classify them
- * This is more reliable than trying to use complex regex patterns
- */
-export declare const allMathPatternsRegex: RegExp;
-/**
- * Creates a transaction that migrates existing math strings in the document to new math nodes.
- * This function traverses the document and replaces LaTeX math syntax with proper math nodes,
- * preserving the mathematical content. It handles both inline and block math expressions.
- *
- * Note: Math formulas inside <pre> and <code> tags are ignored to preserve code formatting.
- *
- * @param editor - The editor instance containing the schema and configuration
- * @param tr - The transaction to modify with the migration operations
- * @returns The modified transaction with math string replacements
- *
- * @example
- * ```typescript
- * const editor = new Editor({ ... })
- * const tr = editor.state.tr
- * const updatedTr = createMathMigrateTransaction(editor, tr)
- * editor.view.dispatch(updatedTr)
- * ```
- */
-export declare function createMathMigrateTransaction(editor: Editor, tr: Transaction): Transaction;
-/**
- * Migrates existing math strings in the editor document to math nodes.
- * This function creates and dispatches a transaction that converts LaTeX math syntax
- * into proper math nodes. It handles both inline math (single dollar signs) and
- * block math (double dollar signs). The migration happens immediately and is not
- * added to the editor's history.
- *
- * Note: Math formulas inside <pre> and <code> tags are ignored to preserve code formatting.
- *
- * @param editor - The editor instance to perform the migration on
- *
- * @example
- * ```typescript
- * const editor = new Editor({
- *   extensions: [Mathematics],
- *   content: 'This is inline math: $x^2 + y^2 = z^2$ and block math: $$\frac{a}{b}$$'
- * })
- *
- * // Math strings will be automatically migrated to math nodes
- * migrateMathStrings(editor)
- * ```
- */
-export declare function migrateMathStrings(editor: Editor): void;

package/dist/util/migrateMathStrings.js

@@ -1,192 +0,0 @@
-/**
- * Regular expression to match LaTeX math strings wrapped in single dollar signs.
- * This should not catch dollar signs which are not part of a math expression,
- * like those used for currency or other purposes.
- * It ensures that the dollar signs are not preceded or followed by digits,
- * allowing for proper identification of inline math expressions.
- *
- * - `$x^2 + y^2 = z^2$` will match
- * - `This is $inline math$ in text.` will match
- * - `This is $100$ dollars.` will not match (as it is not a math expression)
- * - `This is $x^2 + y^2 = z^2$ and $100$ dollars.` will match both math expressions
- * - `$$\frac{a}{b}$$` will NOT match (block math should be handled separately)
- */
-export var mathMigrationRegex = /\$(?!\d+\$)(?!\$)(.+?)(?<!\$)\$(?!\d)(?!\$)/g;
-
-/**
- * Regular expression to match LaTeX math strings wrapped in double dollar signs.
- * This matches block-level math expressions that should be displayed on their own line.
- *
- * - `$$\frac{a}{b}$$` will match
- * - `$$\int_{-\infty}^{\infty} e^{-x^2} dx = \sqrt{\pi}$$` will match
- * - `$$100$$ dollars` will not match (as it is not a math expression)
- */
-export var blockMathMigrationRegex = /\$\$([^$]+)\$\$/g;
-
-/**
- * Alternative approach: First find all math patterns, then classify them
- * This is more reliable than trying to use complex regex patterns
- */
-export var allMathPatternsRegex = /\$\$?[^$]*\$\$?/g;
-
-/**
- * Creates a transaction that migrates existing math strings in the document to new math nodes.
- * This function traverses the document and replaces LaTeX math syntax with proper math nodes,
- * preserving the mathematical content. It handles both inline and block math expressions.
- * 
- * Note: Math formulas inside <pre> and <code> tags are ignored to preserve code formatting.
- *
- * @param editor - The editor instance containing the schema and configuration
- * @param tr - The transaction to modify with the migration operations
- * @returns The modified transaction with math string replacements
- *
- * @example
- * ```typescript
- * const editor = new Editor({ ... })
- * const tr = editor.state.tr
- * const updatedTr = createMathMigrateTransaction(editor, tr)
- * editor.view.dispatch(updatedTr)
- * ```
- */
-export function createMathMigrateTransaction(editor, tr) {
-  var inlineMathNode = editor.schema.nodes.inlineMath;
-  var blockMathNode = editor.schema.nodes.blockMath;
-
-  // 收集所有需要处理的数学公式，按位置排序
-  var allMathReplacements = [];
-
-  // 第一遍：收集所有数学公式信息
-  tr.doc.descendants(function (node, pos) {
-    // 跳过代码块和预格式化文本
-    if (node.marks.some(function (mark) {
-      return mark.type.name === 'codeBlock' || mark.type.name === 'code';
-    })) {
-      return;
-    }
-    if (!node.isText || !node.text || !node.text.includes('$')) {
-      return;
-    }
-    var text = node.text;
-
-    // 使用更可靠的方法：先找到所有可能的数学模式，然后分类
-    var allMatches = text.match(allMathPatternsRegex);
-    if (!allMatches) {
-      return;
-    }
-
-    // 按位置排序，从后往前处理，避免位置偏移问题
-    var sortedMatches = allMatches.map(function (match) {
-      var isBlock = match.startsWith('$$') && match.endsWith('$$');
-      var type = isBlock ? 'block' : 'inline';
-      return {
-        match: match,
-        start: text.indexOf(match),
-        end: text.indexOf(match) + match.length,
-        type: type
-      };
-    }).sort(function (a, b) {
-      return b.start - a.start;
-    }); // 从后往前排序
-
-    sortedMatches.forEach(function (_ref) {
-      var match = _ref.match,
-        start = _ref.start,
-        end = _ref.end,
-        type = _ref.type;
-      var from = tr.mapping.map(pos + start);
-      var to = tr.mapping.map(pos + end);
-      var $from = tr.doc.resolve(from);
-      var parent = $from.parent;
-      var index = $from.index();
-      var latex;
-      if (type === 'block') {
-        latex = match.slice(2, -2); // 移除 $$ 符号
-      } else {
-        latex = match.slice(1, -1); // 移除 $ 符号
-      }
-      allMathReplacements.push({
-        pos: from,
-        match: match,
-        type: type,
-        latex: latex,
-        parent: parent,
-        index: index
-      });
-    });
-  });
-
-  // 按位置从后往前排序，避免位置偏移问题
-  allMathReplacements.sort(function (a, b) {
-    return b.pos - a.pos;
-  });
-
-  // 第二遍：执行替换
-  allMathReplacements.forEach(function (_ref2) {
-    var pos = _ref2.pos,
-      match = _ref2.match,
-      type = _ref2.type,
-      latex = _ref2.latex,
-      parent = _ref2.parent,
-      index = _ref2.index;
-    var mathNode;
-    if (type === 'block') {
-      // 块级数学公式
-      mathNode = blockMathNode;
-    } else {
-      // 行内数学公式
-      mathNode = inlineMathNode;
-    }
-    if (type === 'block') {
-      // 对于块级数学公式，需要特殊处理
-      // 1. 先删除原始文本
-      var endPos = pos + match.length;
-      tr.delete(pos, endPos);
-
-      // 2. 在删除位置插入块级数学节点
-      tr.insert(pos, mathNode.create({
-        latex: latex
-      }));
-    } else {
-      // 对于行内数学公式，在段落内部替换
-      if (!parent.canReplaceWith(index, index + 1, mathNode)) {
-        console.warn("\u65E0\u6CD5\u66FF\u6362\u884C\u5185\u6570\u5B66\u516C\u5F0F:", match);
-        return;
-      }
-      var _endPos = pos + match.length;
-      tr.replaceWith(pos, _endPos, mathNode.create({
-        latex: latex
-      }));
-    }
-  });
-
-  // don't add to history
-  tr.setMeta('addToHistory', false);
-  return tr;
-}
-
-/**
- * Migrates existing math strings in the editor document to math nodes.
- * This function creates and dispatches a transaction that converts LaTeX math syntax
- * into proper math nodes. It handles both inline math (single dollar signs) and
- * block math (double dollar signs). The migration happens immediately and is not
- * added to the editor's history.
- * 
- * Note: Math formulas inside <pre> and <code> tags are ignored to preserve code formatting.
- *
- * @param editor - The editor instance to perform the migration on
- *
- * @example
- * ```typescript
- * const editor = new Editor({
- *   extensions: [Mathematics],
- *   content: 'This is inline math: $x^2 + y^2 = z^2$ and block math: $$\frac{a}{b}$$'
- * })
- *
- * // Math strings will be automatically migrated to math nodes
- * migrateMathStrings(editor)
- * ```
- */
-export function migrateMathStrings(editor) {
-  var tr = createMathMigrateTransaction(editor, editor.state.tr);
-  editor.view.dispatch(tr);
-}