@tiptap/extension-list 3.26.1 → 3.27.0

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { Node, Extension, Editor } from '@tiptap/core';
+import { Node, Extension, Editor, JSONContent } from '@tiptap/core';
 import * as prosemirror_model from 'prosemirror-model';
 import { NodeType, Node as Node$1 } from '@tiptap/pm/model';
 import { EditorState } from '@tiptap/pm/state';
@@ -183,6 +183,71 @@ declare const orderedListInputRegex: RegExp;
  */
 declare const OrderedList: Node<OrderedListOptions, any>;
 
+/**
+ * Marker segment for ordered list lines: numeric, roman, or 1–2 letter alpha.
+ * Roman is matched before alpha so "iii" is roman; invalid romans like "aa" fall through to alpha.
+ */
+declare const ORDERED_LIST_MARKER_PATTERN: string;
+/**
+ * Convert a number to lowercase roman numerals.
+ * @example toRoman(1) // 'i'
+ * @example toRoman(4) // 'iv'
+ */
+declare function toRoman(num: number): string;
+/**
+ * Convert a number to uppercase roman numerals.
+ * @example toRomanUpper(1) // 'I'
+ * @example toRomanUpper(4) // 'IV'
+ */
+declare function toRomanUpper(num: number): string;
+/**
+ * Extract the list marker type from a marker string.
+ * Supports "1", "a", "A", "i", "I" marker styles.
+ *
+ * @param marker The text content of the list marker (e.g. "a", "1", "iii", "b")
+ * @returns The normalized type string, or undefined for default numeric type
+ */
+declare function detectMarkerType(marker: string): string | undefined;
+/**
+ * Convert a list marker string to its numeric start position.
+ *
+ * @param marker The text content of the list marker (e.g. "3", "b", "II")
+ * @returns The 1-based start value for the ordered list
+ */
+declare function markerToStart(marker: string): number;
+/**
+ * Returns true when all markers share the same style and increment by 1.
+ * Style is inferred from the first marker so ambiguous letters (e.g. "c", "i")
+ * are not re-classified differently on later lines.
+ */
+declare function areOrderedListMarkersSequential(markers: string[]): boolean;
+interface ParsedListMarker {
+    type?: string;
+    start: number;
+}
+/**
+ * Parse a list marker into HTML ordered-list attrs (type + start).
+ */
+declare function parseListMarker(marker: string): ParsedListMarker;
+/**
+ * Build orderedList node attrs from the first list item marker.
+ */
+declare function buildOrderedListAttrsFromMarker(marker: string): Record<string, string | number>;
+/**
+ * Returns the list marker prefix for a given item at a given index.
+ *
+ * @param type The list type attribute (e.g. "a", "A", "i", "I", null/undefined for default)
+ * @param index The zero-based index of the list item
+ * @param separator The separator to use (default: ". ")
+ * @returns The marker string (e.g. "a. ", "I. ", "1. ")
+ */
+declare function getListMarker(type: string | null | undefined, index: number, separator?: string): string;
+
+/**
+ * Parse plain-text pasted ordered list lines into JSONContent, or null if not a typed list.
+ */
+declare function parsePlainTextOrderedListPaste(text: string): JSONContent | null;
+
 interface TaskItemOptions {
     /**
      * A callback function that is called when the checkbox is clicked while the editor is in readonly mode.
@@ -297,4 +362,4 @@ interface ListKitOptions {
  */
 declare const ListKit: Extension<ListKitOptions, any>;
 
-export { BulletList, type BulletListOptions, ListItem, type ListItemOptions, ListKeymap, type ListKeymapOptions, ListKit, type ListKitOptions, OrderedList, type OrderedListOptions, TaskItem, type TaskItemOptions, TaskList, type TaskListOptions, bulletListInputRegex, inputRegex, index as listHelpers, orderedListInputRegex };
+export { BulletList, type BulletListOptions, ListItem, type ListItemOptions, ListKeymap, type ListKeymapOptions, ListKit, type ListKitOptions, ORDERED_LIST_MARKER_PATTERN, OrderedList, type OrderedListOptions, TaskItem, type TaskItemOptions, TaskList, type TaskListOptions, areOrderedListMarkersSequential, buildOrderedListAttrsFromMarker, bulletListInputRegex, detectMarkerType, getListMarker, inputRegex, index as listHelpers, markerToStart, orderedListInputRegex, parseListMarker, parsePlainTextOrderedListPaste, toRoman, toRomanUpper };

package/dist/index.js

@@ -194,6 +194,194 @@ var createBranchingListDeleteKeymap = (itemName, wrapperNames) => {
   });
 };
 
+// src/ordered-list/roman.ts
+var ROMAN_NUMERALS = [
+  [1e3, "m"],
+  [900, "cm"],
+  [500, "d"],
+  [400, "cd"],
+  [100, "c"],
+  [90, "xc"],
+  [50, "l"],
+  [40, "xl"],
+  [10, "x"],
+  [9, "ix"],
+  [5, "v"],
+  [4, "iv"],
+  [1, "i"]
+];
+var ALPHA_NUMERALS = "abcdefghijklmnopqrstuvwxyz";
+var ORDERED_LIST_ALPHA_MARKER_PATTERN = "[a-zA-Z]{1,2}";
+var ORDERED_LIST_MARKER_PATTERN = String.raw`\d+|[ivxlcdmIVXLCDM]+|${ORDERED_LIST_ALPHA_MARKER_PATTERN}`;
+function toRoman(num) {
+  let remaining = num;
+  let result = "";
+  for (const [value, numeral] of ROMAN_NUMERALS) {
+    while (remaining >= value) {
+      result += numeral;
+      remaining -= value;
+    }
+  }
+  return result;
+}
+function toRomanUpper(num) {
+  return toRoman(num).toUpperCase();
+}
+function fromRoman(roman) {
+  const lower = roman.toLowerCase();
+  let index = 0;
+  let result = 0;
+  while (index < lower.length) {
+    let matched = false;
+    for (const [value, numeral] of ROMAN_NUMERALS) {
+      if (lower.startsWith(numeral, index)) {
+        result += value;
+        index += numeral.length;
+        matched = true;
+        break;
+      }
+    }
+    if (!matched) {
+      return 0;
+    }
+  }
+  return result;
+}
+function isValidRoman(marker) {
+  if (!/^[ivxlcdmIVXLCDM]+$/.test(marker)) {
+    return false;
+  }
+  const value = fromRoman(marker);
+  if (value <= 0) {
+    return false;
+  }
+  const expected = marker === marker.toLowerCase() ? toRoman(value) : toRomanUpper(value);
+  return expected === marker;
+}
+function fromAlpha(marker) {
+  const lower = marker.toLowerCase();
+  if (lower.length === 1) {
+    return lower.charCodeAt(0) - "a".charCodeAt(0) + 1;
+  }
+  if (lower.length === 2) {
+    const first = lower.charCodeAt(0) - "a".charCodeAt(0);
+    const second = lower.charCodeAt(1) - "a".charCodeAt(0);
+    return (first + 1) * 26 + second + 1;
+  }
+  return 0;
+}
+function toRomanAlpha(num) {
+  if (num <= 26) {
+    return ALPHA_NUMERALS[num - 1];
+  }
+  const first = Math.floor((num - 1) / 26) - 1;
+  const second = (num - 1) % 26;
+  if (first < 0) {
+    return ALPHA_NUMERALS[second];
+  }
+  return ALPHA_NUMERALS[first] + ALPHA_NUMERALS[second];
+}
+function detectMarkerType(marker) {
+  if (!marker || /^\d+$/.test(marker)) {
+    return void 0;
+  }
+  if (isValidRoman(marker)) {
+    return marker === marker.toLowerCase() ? "i" : "I";
+  }
+  if (/^[a-z]{1,2}$/.test(marker)) {
+    return "a";
+  }
+  if (/^[A-Z]{1,2}$/.test(marker)) {
+    return "A";
+  }
+  return void 0;
+}
+function markerToStart(marker) {
+  if (/^\d+$/.test(marker)) {
+    return parseInt(marker, 10);
+  }
+  const type = detectMarkerType(marker);
+  if (type === "i" || type === "I") {
+    return fromRoman(marker);
+  }
+  if (type === "a" || type === "A") {
+    const start = fromAlpha(marker);
+    return start > 0 ? start : 1;
+  }
+  const parsed = parseInt(marker, 10);
+  return Number.isNaN(parsed) ? 1 : parsed;
+}
+function startToMarker(type, start) {
+  if (type === "numeric") {
+    return String(start);
+  }
+  switch (type) {
+    case "a":
+      return toRomanAlpha(start);
+    case "A":
+      return toRomanAlpha(start).toUpperCase();
+    case "i":
+      return toRoman(start);
+    case "I":
+      return toRomanUpper(start);
+    default:
+      return String(start);
+  }
+}
+function areOrderedListMarkersSequential(markers) {
+  var _a;
+  if (markers.length === 0) {
+    return false;
+  }
+  const firstType = (_a = detectMarkerType(markers[0])) != null ? _a : "numeric";
+  const firstStart = markerToStart(markers[0]);
+  if (firstStart < 1) {
+    return false;
+  }
+  for (let i = 0; i < markers.length; i++) {
+    const expected = startToMarker(firstType, firstStart + i);
+    if (markers[i] !== expected) {
+      return false;
+    }
+  }
+  return true;
+}
+function parseListMarker(marker) {
+  return {
+    type: detectMarkerType(marker),
+    start: markerToStart(marker)
+  };
+}
+function buildOrderedListAttrsFromMarker(marker) {
+  const { type, start } = parseListMarker(marker);
+  const attrs = {};
+  if (type) {
+    attrs.type = type;
+  }
+  if (start !== 1) {
+    attrs.start = start;
+  }
+  return attrs;
+}
+function getListMarker(type, index, separator = ". ") {
+  const position = index + 1;
+  if (!type || type === "1") {
+    return `${position}${separator}`;
+  }
+  switch (type) {
+    case "a":
+      return `${toRomanAlpha(position)}${separator}`;
+    case "A":
+      return `${toRomanAlpha(position).toUpperCase()}${separator}`;
+    case "i":
+      return `${toRoman(position)}${separator}`;
+    case "I":
+      return `${toRomanUpper(position)}${separator}`;
+    default:
+      return `${position}${separator}`;
+  }
+}
+
 // src/item/list-item.ts
 function isSameLineOrderedListToken(token) {
   var _a, _b;
@@ -296,13 +484,15 @@ var ListItem = Node2.create({
       node,
       h,
       (context) => {
-        var _a, _b;
+        var _a, _b, _c, _d;
         if (context.parentType === "bulletList") {
           return "- ";
         }
         if (context.parentType === "orderedList") {
           const start = ((_b = (_a = context.meta) == null ? void 0 : _a.parentAttrs) == null ? void 0 : _b.start) || 1;
-          return `${start + context.index}. `;
+          const type = (_d = (_c = context.meta) == null ? void 0 : _c.parentAttrs) == null ? void 0 : _d.type;
+          const index = start - 1 + (context.index || 0);
+          return getListMarker(type, index, ". ");
         }
         return "- ";
       },
@@ -596,17 +786,25 @@ var ListKeymap = Extension2.create({
 import { Extension as Extension3 } from "@tiptap/core";
 
 // src/ordered-list/ordered-list.ts
+import { Plugin } from "@tiptap/pm/state";
 import { mergeAttributes as mergeAttributes3, Node as Node3, wrappingInputRule as wrappingInputRule2 } from "@tiptap/core";
 
 // src/ordered-list/utils.ts
-var ORDERED_LIST_ITEM_REGEX = /^(\s*)(\d+)\.\s+(.*)$/;
+var ORDERED_LIST_ITEM_REGEX = new RegExp(
+  `^(\\s*)(${ORDERED_LIST_MARKER_PATTERN})([.)])\\s+(.*)$`
+);
+var ORDERED_LIST_LINE_START_REGEX = new RegExp(
+  `^(\\s*)(${ORDERED_LIST_MARKER_PATTERN})([.)])\\s+`
+);
 var INDENTED_LINE_REGEX = /^\s/;
+function isOrderedListMarkerLine(line) {
+  return ORDERED_LIST_ITEM_REGEX.test(line.trimStart());
+}
 function isBlockContentLine(line) {
   const trimmedLine = line.trimStart();
   return (
     // oxlint-disable-next-line prefer-string-starts-ends-with
-    /^[-+*]\s+/.test(trimmedLine) || // oxlint-disable-next-line prefer-string-starts-ends-with
-    /^\d+\.\s+/.test(trimmedLine) || // oxlint-disable-next-line prefer-string-starts-ends-with
+    /^[-+*]\s+/.test(trimmedLine) || isOrderedListMarkerLine(trimmedLine) || // oxlint-disable-next-line prefer-string-starts-ends-with
     /^>\s?/.test(trimmedLine) || // oxlint-disable-next-line prefer-string-starts-ends-with
     /^```/.test(trimmedLine) || // oxlint-disable-next-line prefer-string-starts-ends-with
     /^~~~/.test(trimmedLine)
@@ -648,8 +846,11 @@ function collectOrderedListItems(lines) {
     if (!match) {
       break;
     }
-    const [, indent, number, content] = match;
+    const [, indent, marker, _separator, content] = match;
     const indentLevel = indent.length;
+    const number = parseInt(marker, 10);
+    const markerType = isNaN(number) ? detectMarkerType(marker) : void 0;
+    const itemNumber = isNaN(number) ? markerToStart(marker) : number;
     const itemContentLines = [content];
     let nextLineIndex = currentLineIndex + 1;
     const itemLines = [line];
@@ -680,7 +881,8 @@ function collectOrderedListItems(lines) {
     }
     listItems.push({
       indent: indentLevel,
-      number: parseInt(number, 10),
+      number: itemNumber,
+      type: markerType,
       content: itemContentLines.join("\n").trim(),
       contentLines: itemContentLines,
       raw: itemLines.join("\n")
@@ -690,6 +892,44 @@ function collectOrderedListItems(lines) {
   }
   return [listItems, consumed];
 }
+var PLAIN_TEXT_ORDERED_LIST_LINE_REGEX = new RegExp(
+  `^(${ORDERED_LIST_MARKER_PATTERN})([.)])\\s+(.+)$`
+);
+function parsePlainTextOrderedListPaste(text) {
+  const lines = text.split("\n").filter((l) => l.trim().length > 0);
+  if (lines.length === 0) {
+    return null;
+  }
+  const parsedItems = [];
+  for (const line of lines) {
+    const match = line.trim().match(PLAIN_TEXT_ORDERED_LIST_LINE_REGEX);
+    if (!match) {
+      return null;
+    }
+    parsedItems.push({
+      marker: match[1],
+      content: match[3]
+    });
+  }
+  const markers = parsedItems.map((item) => item.marker);
+  if (!areOrderedListMarkersSequential(markers)) {
+    return null;
+  }
+  const attrs = buildOrderedListAttrsFromMarker(parsedItems[0].marker);
+  return {
+    type: "orderedList",
+    attrs,
+    content: parsedItems.map((item) => ({
+      type: "listItem",
+      content: [
+        {
+          type: "paragraph",
+          content: [{ type: "text", text: item.content }]
+        }
+      ]
+    }))
+  };
+}
 function buildNestedStructure(items, baseIndent, lexer) {
   const result = [];
   let currentIndex = 0;
@@ -724,6 +964,7 @@ function buildNestedStructure(items, baseIndent, lexer) {
           type: "list",
           ordered: true,
           start: nestedItems[0].number,
+          typeMarker: nestedItems[0].type,
           items: nestedListItems,
           raw: nestedItems.map((nestedItem) => nestedItem.raw).join("\n")
         });
@@ -775,6 +1016,27 @@ function parseListItems(items, helpers) {
 var ListItemName2 = "listItem";
 var TextStyleName2 = "textStyle";
 var orderedListInputRegex = /^(\d+)\.\s$/;
+function cssListStyleTypeToHtmlType(style) {
+  const match = style.match(/list-style-type\s*:\s*([^;]+)/i);
+  if (!match) {
+    return null;
+  }
+  const cssValue = match[1].trim().toLowerCase();
+  switch (cssValue) {
+    case "upper-roman":
+      return "I";
+    case "lower-roman":
+      return "i";
+    case "upper-alpha":
+    case "upper-latin":
+      return "A";
+    case "lower-alpha":
+    case "lower-latin":
+      return "a";
+    default:
+      return null;
+  }
+}
 var OrderedList = Node3.create({
   name: "orderedList",
   addOptions() {
@@ -799,7 +1061,30 @@ var OrderedList = Node3.create({
       },
       type: {
         default: null,
-        parseHTML: (element) => element.getAttribute("type")
+        parseHTML: (element) => {
+          const htmlType = element.getAttribute("type");
+          if (htmlType) {
+            return htmlType;
+          }
+          const style = element.getAttribute("style");
+          if (style) {
+            const mappedFromOl = cssListStyleTypeToHtmlType(style);
+            if (mappedFromOl) {
+              return mappedFromOl;
+            }
+          }
+          const firstLi = element.querySelector("li");
+          if (firstLi) {
+            const liStyle = firstLi.getAttribute("style");
+            if (liStyle) {
+              const mappedFromLi = cssListStyleTypeToHtmlType(liStyle);
+              if (mappedFromLi) {
+                return mappedFromLi;
+              }
+            }
+          }
+          return null;
+        }
       }
     };
   },
@@ -811,8 +1096,15 @@ var OrderedList = Node3.create({
     ];
   },
   renderHTML({ HTMLAttributes }) {
-    const { start, ...attributesWithoutStart } = HTMLAttributes;
-    return start === 1 ? ["ol", mergeAttributes3(this.options.HTMLAttributes, attributesWithoutStart), 0] : ["ol", mergeAttributes3(this.options.HTMLAttributes, HTMLAttributes), 0];
+    const { start, type, ...attributesWithoutType } = HTMLAttributes;
+    const attrs = mergeAttributes3(this.options.HTMLAttributes, attributesWithoutType);
+    if (start !== 1) {
+      attrs.start = start;
+    }
+    if (type && type !== "1") {
+      attrs.type = type;
+    }
+    return ["ol", attrs, 0];
   },
   markdownTokenName: "list",
   parseMarkdown: (token, helpers) => {
@@ -820,11 +1112,19 @@ var OrderedList = Node3.create({
       return [];
     }
     const startValue = token.start || 1;
+    const typeValue = token.typeMarker;
     const content = token.items ? parseListItems(token.items, helpers) : [];
+    const attrs = {};
     if (startValue !== 1) {
+      attrs.start = startValue;
+    }
+    if (typeValue) {
+      attrs.type = typeValue;
+    }
+    if (Object.keys(attrs).length > 0) {
       return {
         type: "orderedList",
-        attrs: { start: startValue },
+        attrs,
         content
       };
     }
@@ -843,12 +1143,12 @@ var OrderedList = Node3.create({
     name: "orderedList",
     level: "block",
     start: (src) => {
-      const match = src.match(/^(\s*)(\d+)\.\s+/);
+      const match = src.match(ORDERED_LIST_LINE_START_REGEX);
       const index = match == null ? void 0 : match.index;
       return index !== void 0 ? index : -1;
     },
     tokenize: (src, _tokens, lexer) => {
-      var _a;
+      var _a, _b;
       const lines = src.split("\n");
       const [listItems, consumed] = collectOrderedListItems(lines);
       if (listItems.length === 0) {
@@ -859,10 +1159,12 @@ var OrderedList = Node3.create({
         return void 0;
       }
       const startValue = ((_a = listItems[0]) == null ? void 0 : _a.number) || 1;
+      const typeMarker = (_b = listItems[0]) == null ? void 0 : _b.type;
       return {
         type: "list",
         ordered: true,
         start: startValue,
+        typeMarker,
         items,
         raw: lines.slice(0, consumed).join("\n")
       };
@@ -886,12 +1188,47 @@ var OrderedList = Node3.create({
       "Mod-Shift-7": () => this.editor.commands.toggleOrderedList()
     };
   },
+  addProseMirrorPlugins() {
+    return [
+      new Plugin({
+        props: {
+          handlePaste: (view, event) => {
+            var _a, _b;
+            const html = (_a = event.clipboardData) == null ? void 0 : _a.getData("text/html");
+            if (html == null ? void 0 : html.trim()) {
+              return false;
+            }
+            const text = (_b = event.clipboardData) == null ? void 0 : _b.getData("text/plain");
+            if (!text) {
+              return false;
+            }
+            const orderedListContent = parsePlainTextOrderedListPaste(text);
+            if (!orderedListContent) {
+              return false;
+            }
+            try {
+              const orderedListNode = view.state.schema.nodeFromJSON(orderedListContent);
+              const tr = view.state.tr.replaceSelectionWith(orderedListNode);
+              view.dispatch(tr);
+              return true;
+            } catch {
+              return false;
+            }
+          }
+        }
+      })
+    ];
+  },
   addInputRules() {
+    const joinPredicate = (match, node) => {
+      const hasDefaultType = !node.attrs.type || node.attrs.type === "1";
+      return hasDefaultType && node.childCount + node.attrs.start === +match[1];
+    };
     let inputRule = wrappingInputRule2({
       find: orderedListInputRegex,
       type: this.type,
       getAttributes: (match) => ({ start: +match[1] }),
-      joinPredicate: (match, node) => node.childCount + node.attrs.start === +match[1]
+      joinPredicate
     });
     if (this.options.keepMarks || this.options.keepAttributes) {
       inputRule = wrappingInputRule2({
@@ -900,7 +1237,7 @@ var OrderedList = Node3.create({
         keepMarks: this.options.keepMarks,
         keepAttributes: this.options.keepAttributes,
         getAttributes: (match) => ({ start: +match[1], ...this.editor.getAttributes(TextStyleName2) }),
-        joinPredicate: (match, node) => node.childCount + node.attrs.start === +match[1],
+        joinPredicate,
         editor: this.editor
       });
     }
@@ -1284,12 +1621,22 @@ export {
   ListItem,
   ListKeymap,
   ListKit,
+  ORDERED_LIST_MARKER_PATTERN,
   OrderedList,
   TaskItem,
   TaskList,
+  areOrderedListMarkersSequential,
+  buildOrderedListAttrsFromMarker,
   bulletListInputRegex,
+  detectMarkerType,
+  getListMarker,
   inputRegex,
   listHelpers_exports as listHelpers,
-  orderedListInputRegex
+  markerToStart,
+  orderedListInputRegex,
+  parseListMarker,
+  parsePlainTextOrderedListPaste,
+  toRoman,
+  toRomanUpper
 };
 //# sourceMappingURL=index.js.map