@tiptap/extension-ruby-text 3.30.2 → 3.30.3

package/dist/index.cjs

@@ -1,317 +1,279 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  RubyText: () => RubyText,
-  default: () => index_default
+Object.defineProperties(exports, {
+	__esModule: { value: true },
+	[Symbol.toStringTag]: { value: "Module" }
 });
-module.exports = __toCommonJS(index_exports);
-
-// src/ruby-text.ts
-var import_core = require("@tiptap/core");
-
-// src/ruby-text-decoration-plugin.ts
-var import_state = require("@tiptap/pm/state");
-var import_view = require("@tiptap/pm/view");
-var rubyTextDecorationPluginKey = new import_state.PluginKey("rubyTextDecoration");
-var editSessions = /* @__PURE__ */ new WeakMap();
+let _tiptap_core = require("@tiptap/core");
+let _tiptap_pm_state = require("@tiptap/pm/state");
+let _tiptap_pm_view = require("@tiptap/pm/view");
+//#region src/ruby-text-decoration-plugin.ts
+const rubyTextDecorationPluginKey = new _tiptap_pm_state.PluginKey("rubyTextDecoration");
+const editSessions = /* @__PURE__ */ new WeakMap();
 function isImeEvent(event) {
-  const legacyKeyCode = event.keyCode;
-  return event.isComposing || legacyKeyCode === 229;
+	const legacyKeyCode = event.keyCode;
+	return event.isComposing || legacyKeyCode === 229;
 }
-function defaultRenderAnnotationEditor({
-  annotation,
-  submit,
-  dismiss
-}) {
-  const input = document.createElement("input");
-  input.type = "text";
-  input.value = annotation;
-  input.size = Math.max(annotation.length, 1);
-  input.setAttribute("aria-label", "Ruby text annotation");
-  input.addEventListener("focus", () => input.select(), { once: true });
-  input.addEventListener("blur", () => dismiss());
-  input.addEventListener("keydown", (event) => {
-    if (isImeEvent(event)) {
-      return;
-    }
-    if (event.key === "Escape") {
-      event.preventDefault();
-      dismiss();
-    }
-    if (event.key === "Enter") {
-      event.preventDefault();
-      submit(input.value);
-    }
-  });
-  return input;
+/** Default annotation editor: a plain text input. Enter submits, Escape or blur dismisses. */
+function defaultRenderAnnotationEditor({ annotation, submit, dismiss }) {
+	const input = document.createElement("input");
+	input.type = "text";
+	input.value = annotation;
+	input.size = Math.max(annotation.length, 1);
+	input.setAttribute("aria-label", "Ruby text annotation");
+	input.addEventListener("focus", () => input.select(), { once: true });
+	input.addEventListener("blur", () => dismiss());
+	input.addEventListener("keydown", (event) => {
+		if (isImeEvent(event)) return;
+		if (event.key === "Escape") {
+			event.preventDefault();
+			dismiss();
+		}
+		if (event.key === "Enter") {
+			event.preventDefault();
+			submit(input.value);
+		}
+	});
+	return input;
 }
 function createRtElement(annotation, range, rubyTextType, view, options) {
-  const rt = document.createElement("rt");
-  rt.contentEditable = "false";
-  rt.textContent = annotation;
-  let editing = false;
-  const restoreEditorFocus = () => {
-    view.dispatch(view.state.tr.setSelection(import_state.TextSelection.create(view.state.doc, range.to)));
-    view.focus();
-  };
-  if (!options.allowClickToEdit || !view.editable) {
-    return rt;
-  }
-  editSessions.set(rt, () => {
-    editing = false;
-  });
-  const dismiss = () => {
-    if (!editing) {
-      return;
-    }
-    editing = false;
-    rt.textContent = annotation;
-    restoreEditorFocus();
-  };
-  const submit = (value) => {
-    if (!editing) {
-      return;
-    }
-    if (!view.editable || value === annotation) {
-      dismiss();
-      return;
-    }
-    editing = false;
-    const transaction = view.state.tr.addMark(
-      range.from,
-      range.to,
-      rubyTextType.create({ ...range.mark.attrs, rt: value })
-    );
-    view.dispatch(transaction.setSelection(import_state.TextSelection.create(transaction.doc, range.to)));
-    view.focus();
-  };
-  const openEditor = () => {
-    var _a, _b;
-    const renderEditor = (_a = options.renderAnnotationEditor) != null ? _a : defaultRenderAnnotationEditor;
-    const element = renderEditor({ annotation, submit, dismiss, editor: options.editor });
-    rt.replaceChildren(element);
-    const focusTarget = (_b = element.querySelector("[autofocus]")) != null ? _b : element;
-    focusTarget.focus();
-  };
-  rt.addEventListener("click", () => {
-    if (editing || !view.editable) {
-      return;
-    }
-    editing = true;
-    openEditor();
-  });
-  return rt;
+	const rt = document.createElement("rt");
+	rt.contentEditable = "false";
+	rt.textContent = annotation;
+	let editing = false;
+	const restoreEditorFocus = () => {
+		view.dispatch(view.state.tr.setSelection(_tiptap_pm_state.TextSelection.create(view.state.doc, range.to)));
+		view.focus();
+	};
+	if (!options.allowClickToEdit || !view.editable) return rt;
+	editSessions.set(rt, () => {
+		editing = false;
+	});
+	const dismiss = () => {
+		if (!editing) return;
+		editing = false;
+		rt.textContent = annotation;
+		restoreEditorFocus();
+	};
+	const submit = (value) => {
+		if (!editing) return;
+		if (!view.editable || value === annotation) {
+			dismiss();
+			return;
+		}
+		editing = false;
+		const transaction = view.state.tr.addMark(range.from, range.to, rubyTextType.create({
+			...range.mark.attrs,
+			rt: value
+		}));
+		view.dispatch(transaction.setSelection(_tiptap_pm_state.TextSelection.create(transaction.doc, range.to)));
+		view.focus();
+	};
+	const openEditor = () => {
+		var _options$renderAnnota, _element$querySelecto;
+		const element = ((_options$renderAnnota = options.renderAnnotationEditor) !== null && _options$renderAnnota !== void 0 ? _options$renderAnnota : defaultRenderAnnotationEditor)({
+			annotation,
+			submit,
+			dismiss,
+			editor: options.editor
+		});
+		rt.replaceChildren(element);
+		((_element$querySelecto = element.querySelector("[autofocus]")) !== null && _element$querySelecto !== void 0 ? _element$querySelecto : element).focus();
+	};
+	rt.addEventListener("click", () => {
+		if (editing || !view.editable) return;
+		editing = true;
+		openEditor();
+	});
+	return rt;
 }
+/** Gets the mark of ruby text from the given node, if it exists. */
 function getRubyTextMark(node, rubyTextType) {
-  return node.isText ? node.marks.find((candidate) => candidate.type === rubyTextType) : void 0;
+	return node.isText ? node.marks.find((candidate) => candidate.type === rubyTextType) : void 0;
 }
+/** Adds a ruby text range to an existing array of ranges. */
 function addRange(ranges, range) {
-  if (range) {
-    ranges.push(range);
-  }
+	if (range) ranges.push(range);
 }
+/** Can the current range be extended with the given mark at the given position? */
 function canExtendRange(range, mark, pos) {
-  return (range == null ? void 0 : range.to) === pos && range.mark.eq(mark);
+	return (range === null || range === void 0 ? void 0 : range.to) === pos && range.mark.eq(mark);
 }
+/**
+* Gets the next ruby text range based on the current node and position.
+* @param ranges The array of ruby text ranges to add to.
+* @param range The current ruby text range being built.
+* @param node The current ProseMirror node being processed.
+* @param pos The position of the current node in the document.
+* @param rubyTextType The MarkType for ruby text.
+* @returns The updated ruby text range, or null if the current node does not have a ruby text mark.
+*/
 function getNextRange(ranges, range, node, pos, rubyTextType) {
-  const mark = getRubyTextMark(node, rubyTextType);
-  if (!mark) {
-    addRange(ranges, range);
-    return null;
-  }
-  if (range && canExtendRange(range, mark, pos)) {
-    range.to += node.nodeSize;
-    return range;
-  }
-  addRange(ranges, range);
-  return { from: pos, to: pos + node.nodeSize, mark };
+	const mark = getRubyTextMark(node, rubyTextType);
+	if (!mark) {
+		addRange(ranges, range);
+		return null;
+	}
+	if (range && canExtendRange(range, mark, pos)) {
+		range.to += node.nodeSize;
+		return range;
+	}
+	addRange(ranges, range);
+	return {
+		from: pos,
+		to: pos + node.nodeSize,
+		mark
+	};
 }
 function getRubyTextRanges(doc, rubyTextType) {
-  const ranges = [];
-  let range = null;
-  doc.descendants((node, pos) => {
-    range = getNextRange(ranges, range, node, pos, rubyTextType);
-  });
-  addRange(ranges, range);
-  return ranges;
+	const ranges = [];
+	let range = null;
+	doc.descendants((node, pos) => {
+		range = getNextRange(ranges, range, node, pos, rubyTextType);
+	});
+	addRange(ranges, range);
+	return ranges;
 }
-var STOPPED_EVENT_TYPES = /* @__PURE__ */ new Set([
-  "click",
-  "dblclick",
-  "contextmenu",
-  "mousedown",
-  "mouseup",
-  "pointerdown",
-  "pointerup",
-  "touchstart",
-  "touchend",
-  "keydown",
-  "keypress",
-  "keyup",
-  "input",
-  "beforeinput",
-  "compositionstart",
-  "compositionupdate",
-  "compositionend",
-  "paste",
-  "cut",
-  "copy",
-  "focus",
-  "blur",
-  "focusin",
-  "focusout"
+const STOPPED_EVENT_TYPES = /* @__PURE__ */ new Set([
+	"click",
+	"dblclick",
+	"contextmenu",
+	"mousedown",
+	"mouseup",
+	"pointerdown",
+	"pointerup",
+	"touchstart",
+	"touchend",
+	"keydown",
+	"keypress",
+	"keyup",
+	"input",
+	"beforeinput",
+	"compositionstart",
+	"compositionupdate",
+	"compositionend",
+	"paste",
+	"cut",
+	"copy",
+	"focus",
+	"blur",
+	"focusin",
+	"focusout"
 ]);
 function createDecorations(doc, rubyTextType, options) {
-  const decorations = getRubyTextRanges(doc, rubyTextType).map((range) => {
-    var _a;
-    const annotation = (_a = range.mark.attrs.rt) != null ? _a : "";
-    return import_view.Decoration.widget(
-      range.to,
-      (view) => createRtElement(annotation, range, rubyTextType, view, options),
-      {
-        key: `ruby-text-${range.from}-${range.to}-${annotation}`,
-        marks: [range.mark],
-        side: 1,
-        stopEvent: (event) => options.allowClickToEdit && STOPPED_EVENT_TYPES.has(event.type),
-        destroy: (node) => {
-          var _a2;
-          return (_a2 = editSessions.get(node)) == null ? void 0 : _a2();
-        }
-      }
-    );
-  });
-  return import_view.DecorationSet.create(doc, decorations);
+	const decorations = getRubyTextRanges(doc, rubyTextType).map((range) => {
+		var _range$mark$attrs$rt;
+		const annotation = (_range$mark$attrs$rt = range.mark.attrs.rt) !== null && _range$mark$attrs$rt !== void 0 ? _range$mark$attrs$rt : "";
+		return _tiptap_pm_view.Decoration.widget(range.to, (view) => createRtElement(annotation, range, rubyTextType, view, options), {
+			key: `ruby-text-${range.from}-${range.to}-${annotation}`,
+			marks: [range.mark],
+			side: 1,
+			stopEvent: (event) => options.allowClickToEdit && STOPPED_EVENT_TYPES.has(event.type),
+			destroy: (node) => {
+				var _editSessions$get;
+				return (_editSessions$get = editSessions.get(node)) === null || _editSessions$get === void 0 ? void 0 : _editSessions$get();
+			}
+		});
+	});
+	return _tiptap_pm_view.DecorationSet.create(doc, decorations);
 }
 function RubyTextDecorationPlugin(rubyTextType, options) {
-  return new import_state.Plugin({
-    key: rubyTextDecorationPluginKey,
-    state: {
-      init: (_, state) => createDecorations(state.doc, rubyTextType, options),
-      apply: (transaction, decorations) => transaction.docChanged ? createDecorations(transaction.doc, rubyTextType, options) : decorations.map(transaction.mapping, transaction.doc)
-    },
-    props: {
-      decorations: (state) => rubyTextDecorationPluginKey.getState(state)
-    }
-  });
+	return new _tiptap_pm_state.Plugin({
+		key: rubyTextDecorationPluginKey,
+		state: {
+			init: (_, state) => createDecorations(state.doc, rubyTextType, options),
+			apply: (transaction, decorations) => transaction.docChanged ? createDecorations(transaction.doc, rubyTextType, options) : decorations.map(transaction.mapping, transaction.doc)
+		},
+		props: { decorations: (state) => rubyTextDecorationPluginKey.getState(state) }
+	});
 }
-
-// src/ruby-text.ts
-var RubyText = import_core.Mark.create({
-  name: "rubyText",
-  inclusive: false,
-  addOptions() {
-    return {
-      HTMLAttributes: {},
-      allowClickToEdit: true,
-      renderAnnotationEditor: void 0
-    };
-  },
-  addAttributes() {
-    return {
-      rt: {
-        default: null
-      }
-    };
-  },
-  parseHTML() {
-    return [
-      {
-        tag: "ruby",
-        contentElement: (node) => {
-          const rb = node.querySelector("rb");
-          if (rb) {
-            return rb;
-          }
-          const surrogate = document.createElement("span");
-          Array.from(node.childNodes).forEach((child) => {
-            if (child.nodeName !== "RT" && child.nodeName !== "RP") {
-              surrogate.appendChild(child.cloneNode(true));
-            }
-          });
-          return surrogate;
-        },
-        getAttrs: (node) => {
-          var _a;
-          const rt = node.querySelector("rt");
-          if (!rt) {
-            return false;
-          }
-          return { rt: (_a = rt.textContent) != null ? _a : "" };
-        }
-      }
-    ];
-  },
-  renderHTML({ HTMLAttributes, mark }) {
-    return [
-      "ruby",
-      (0, import_core.mergeAttributes)(this.options.HTMLAttributes, HTMLAttributes),
-      ["rb", 0],
-      ...mark.attrs.rt == null ? [] : [["rt", { contenteditable: "false" }, mark.attrs.rt]]
-    ];
-  },
-  addCommands() {
-    return {
-      setRubyText: (attributes) => ({ commands }) => {
-        return commands.setMark(this.name, attributes);
-      },
-      toggleRubyText: (attributes) => ({ commands }) => {
-        return commands.toggleMark(this.name, attributes, { extendEmptyMarkRange: true });
-      },
-      unsetRubyText: () => ({ commands }) => {
-        return commands.unsetMark(this.name, { extendEmptyMarkRange: true });
-      }
-    };
-  },
-  addProseMirrorPlugins() {
-    return [
-      RubyTextDecorationPlugin(this.type, {
-        editor: this.editor,
-        allowClickToEdit: this.options.allowClickToEdit,
-        renderAnnotationEditor: this.options.renderAnnotationEditor
-      })
-    ];
-  },
-  addMarkView() {
-    return ({ HTMLAttributes }) => {
-      const ruby = document.createElement("ruby");
-      Object.entries((0, import_core.mergeAttributes)(this.options.HTMLAttributes, HTMLAttributes)).forEach(
-        ([key, value]) => {
-          if (value != null) {
-            ruby.setAttribute(key, String(value));
-          }
-        }
-      );
-      return {
-        dom: ruby,
-        contentDOM: ruby
-      };
-    };
-  }
+//#endregion
+//#region src/ruby-text.ts
+/**
+* This extension adds support for HTML ruby text annotations.
+* @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/ruby
+*/
+const RubyText = _tiptap_core.Mark.create({
+	name: "rubyText",
+	inclusive: false,
+	addOptions() {
+		return {
+			HTMLAttributes: {},
+			allowClickToEdit: true,
+			renderAnnotationEditor: void 0
+		};
+	},
+	addAttributes() {
+		return { rt: { default: null } };
+	},
+	parseHTML() {
+		return [{
+			tag: "ruby",
+			contentElement: (node) => {
+				const rb = node.querySelector("rb");
+				if (rb) return rb;
+				const surrogate = document.createElement("span");
+				Array.from(node.childNodes).forEach((child) => {
+					if (child.nodeName !== "RT" && child.nodeName !== "RP") surrogate.appendChild(child.cloneNode(true));
+				});
+				return surrogate;
+			},
+			getAttrs: (node) => {
+				var _rt$textContent;
+				const rt = node.querySelector("rt");
+				if (!rt) return false;
+				return { rt: (_rt$textContent = rt.textContent) !== null && _rt$textContent !== void 0 ? _rt$textContent : "" };
+			}
+		}];
+	},
+	renderHTML({ HTMLAttributes, mark }) {
+		return [
+			"ruby",
+			(0, _tiptap_core.mergeAttributes)(this.options.HTMLAttributes, HTMLAttributes),
+			["rb", 0],
+			...mark.attrs.rt == null ? [] : [[
+				"rt",
+				{ contenteditable: "false" },
+				mark.attrs.rt
+			]]
+		];
+	},
+	addCommands() {
+		return {
+			setRubyText: (attributes) => ({ commands }) => {
+				return commands.setMark(this.name, attributes);
+			},
+			toggleRubyText: (attributes) => ({ commands }) => {
+				return commands.toggleMark(this.name, attributes, { extendEmptyMarkRange: true });
+			},
+			unsetRubyText: () => ({ commands }) => {
+				return commands.unsetMark(this.name, { extendEmptyMarkRange: true });
+			}
+		};
+	},
+	addProseMirrorPlugins() {
+		return [RubyTextDecorationPlugin(this.type, {
+			editor: this.editor,
+			allowClickToEdit: this.options.allowClickToEdit,
+			renderAnnotationEditor: this.options.renderAnnotationEditor
+		})];
+	},
+	addMarkView() {
+		return ({ HTMLAttributes }) => {
+			const ruby = document.createElement("ruby");
+			Object.entries((0, _tiptap_core.mergeAttributes)(this.options.HTMLAttributes, HTMLAttributes)).forEach(([key, value]) => {
+				if (value != null) ruby.setAttribute(key, String(value));
+			});
+			return {
+				dom: ruby,
+				contentDOM: ruby
+			};
+		};
+	}
 });
+//#endregion
+//#region src/index.ts
+var src_default = RubyText;
+//#endregion
+exports.RubyText = RubyText;
+exports.default = src_default;
 
-// src/index.ts
-var index_default = RubyText;
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  RubyText
-});
 //# sourceMappingURL=index.cjs.map