rhino-editor
Version:
A custom element wrapped rich text editor
2,669 lines • 84.8 kB
JavaScript
import {
AddAttachmentEvent
} from "./chunk-CZRGOOEV.js";
import {
RhinoFocusEvent
} from "./chunk-CO3NBTSN.js";
import {
RhinoChangeEvent
} from "./chunk-BYRYOV3A.js";
import {
RhinoBlurEvent
} from "./chunk-RXTNV3CH.js";
import {
InitializeEvent
} from "./chunk-TUFYCG5K.js";
import {
FileAcceptEvent
} from "./chunk-CVO5J527.js";
import {
BeforeInitializeEvent
} from "./chunk-PBNR35P2.js";
import {
SelectionChangeEvent
} from "./chunk-OVNNLQEY.js";
import {
editor_default
} from "./chunk-MGNIRTEI.js";
import {
RhinoStarterKit
} from "./chunk-KOV2CTSN.js";
import {
Strike
} from "./chunk-QZU22EPA.js";
import {
AttachmentRemoveEvent
} from "./chunk-3PWTYHXV.js";
import {
Decoration,
DecorationSet,
Editor,
Extension,
Mark,
Node,
callOrReturn,
getExtensionField,
isNodeSelection,
keydownHandler,
markInputRule,
markPasteRule,
mergeAttributes,
nodeInputRule,
textblockTypeInputRule,
wrappingInputRule
} from "./chunk-TVRRLXKH.js";
import {
DOMSerializer,
Fragment,
Mapping,
NodeSelection,
Plugin,
PluginKey,
Selection,
Slice,
TextSelection,
dropPoint
} from "./chunk-ZEDCHN2I.js";
import {
AttachmentManager
} from "./chunk-KUC52EW2.js";
import {
AttachmentUpload,
AttachmentUploadCompleteEvent,
AttachmentUploadStartEvent
} from "./chunk-VCQBXCNZ.js";
import {
AttachmentEditor,
BaseElement
} from "./chunk-CMZKZQUC.js";
import {
normalize
} from "./chunk-ASLJ2UQV.js";
import {
tipTapCoreStyles
} from "./chunk-MQ7PHBP3.js";
import {
ke
} from "./chunk-7BUHDUOD.js";
// node_modules/.pnpm/@tiptap+extension-blockquote@2.9.1_@tiptap+core@2.9.1_@tiptap+pm@2.9.1_/node_modules/@tiptap/extension-blockquote/dist/index.js
var inputRegex = /^\s*>\s$/;
var Blockquote = Node.create({
name: "blockquote",
addOptions() {
return {
HTMLAttributes: {}
};
},
content: "block+",
group: "block",
defining: true,
parseHTML() {
return [
{ tag: "blockquote" }
];
},
renderHTML({ HTMLAttributes }) {
return ["blockquote", mergeAttributes(this.options.HTMLAttributes, HTMLAttributes), 0];
},
addCommands() {
return {
setBlockquote: () => ({ commands }) => {
return commands.wrapIn(this.name);
},
toggleBlockquote: () => ({ commands }) => {
return commands.toggleWrap(this.name);
},
unsetBlockquote: () => ({ commands }) => {
return commands.lift(this.name);
}
};
},
addKeyboardShortcuts() {
return {
"Mod-Shift-b": () => this.editor.commands.toggleBlockquote()
};
},
addInputRules() {
return [
wrappingInputRule({
find: inputRegex,
type: this.type
})
];
}
});
// node_modules/.pnpm/@tiptap+extension-bold@2.9.1_@tiptap+core@2.9.1_@tiptap+pm@2.9.1_/node_modules/@tiptap/extension-bold/dist/index.js
var starInputRegex = /(?:^|\s)(\*\*(?!\s+\*\*)((?:[^*]+))\*\*(?!\s+\*\*))$/;
var starPasteRegex = /(?:^|\s)(\*\*(?!\s+\*\*)((?:[^*]+))\*\*(?!\s+\*\*))/g;
var underscoreInputRegex = /(?:^|\s)(__(?!\s+__)((?:[^_]+))__(?!\s+__))$/;
var underscorePasteRegex = /(?:^|\s)(__(?!\s+__)((?:[^_]+))__(?!\s+__))/g;
var Bold = Mark.create({
name: "bold",
addOptions() {
return {
HTMLAttributes: {}
};
},
parseHTML() {
return [
{
tag: "strong"
},
{
tag: "b",
getAttrs: (node) => node.style.fontWeight !== "normal" && null
},
{
style: "font-weight=400",
clearMark: (mark) => mark.type.name === this.name
},
{
style: "font-weight",
getAttrs: (value) => /^(bold(er)?|[5-9]\d{2,})$/.test(value) && null
}
];
},
renderHTML({ HTMLAttributes }) {
return ["strong", mergeAttributes(this.options.HTMLAttributes, HTMLAttributes), 0];
},
addCommands() {
return {
setBold: () => ({ commands }) => {
return commands.setMark(this.name);
},
toggleBold: () => ({ commands }) => {
return commands.toggleMark(this.name);
},
unsetBold: () => ({ commands }) => {
return commands.unsetMark(this.name);
}
};
},
addKeyboardShortcuts() {
return {
"Mod-b": () => this.editor.commands.toggleBold(),
"Mod-B": () => this.editor.commands.toggleBold()
};
},
addInputRules() {
return [
markInputRule({
find: starInputRegex,
type: this.type
}),
markInputRule({
find: underscoreInputRegex,
type: this.type
})
];
},
addPasteRules() {
return [
markPasteRule({
find: starPasteRegex,
type: this.type
}),
markPasteRule({
find: underscorePasteRegex,
type: this.type
})
];
}
});
// node_modules/.pnpm/@tiptap+extension-bullet-list@2.9.1_@tiptap+core@2.9.1_@tiptap+pm@2.9.1_/node_modules/@tiptap/extension-bullet-list/dist/index.js
var ListItemName = "listItem";
var TextStyleName = "textStyle";
var inputRegex2 = /^\s*([-+*])\s$/;
var BulletList = Node.create({
name: "bulletList",
addOptions() {
return {
itemTypeName: "listItem",
HTMLAttributes: {},
keepMarks: false,
keepAttributes: false
};
},
group: "block list",
content() {
return `${this.options.itemTypeName}+`;
},
parseHTML() {
return [
{ tag: "ul" }
];
},
renderHTML({ HTMLAttributes }) {
return ["ul", mergeAttributes(this.options.HTMLAttributes, HTMLAttributes), 0];
},
addCommands() {
return {
toggleBulletList: () => ({ commands, chain }) => {
if (this.options.keepAttributes) {
return chain().toggleList(this.name, this.options.itemTypeName, this.options.keepMarks).updateAttributes(ListItemName, this.editor.getAttributes(TextStyleName)).run();
}
return commands.toggleList(this.name, this.options.itemTypeName, this.options.keepMarks);
}
};
},
addKeyboardShortcuts() {
return {
"Mod-Shift-8": () => this.editor.commands.toggleBulletList()
};
},
addInputRules() {
let inputRule = wrappingInputRule({
find: inputRegex2,
type: this.type
});
if (this.options.keepMarks || this.options.keepAttributes) {
inputRule = wrappingInputRule({
find: inputRegex2,
type: this.type,
keepMarks: this.options.keepMarks,
keepAttributes: this.options.keepAttributes,
getAttributes: () => {
return this.editor.getAttributes(TextStyleName);
},
editor: this.editor
});
}
return [
inputRule
];
}
});
// node_modules/.pnpm/@tiptap+extension-code@2.9.1_@tiptap+core@2.9.1_@tiptap+pm@2.9.1_/node_modules/@tiptap/extension-code/dist/index.js
var inputRegex3 = /(?:^|\s)(`(?!\s+`)((?:[^`]+))`(?!\s+`))$/;
var pasteRegex = /(?:^|\s)(`(?!\s+`)((?:[^`]+))`(?!\s+`))/g;
var Code = Mark.create({
name: "code",
addOptions() {
return {
HTMLAttributes: {}
};
},
excludes: "_",
code: true,
exitable: true,
parseHTML() {
return [
{ tag: "code" }
];
},
renderHTML({ HTMLAttributes }) {
return ["code", mergeAttributes(this.options.HTMLAttributes, HTMLAttributes), 0];
},
addCommands() {
return {
setCode: () => ({ commands }) => {
return commands.setMark(this.name);
},
toggleCode: () => ({ commands }) => {
return commands.toggleMark(this.name);
},
unsetCode: () => ({ commands }) => {
return commands.unsetMark(this.name);
}
};
},
addKeyboardShortcuts() {
return {
"Mod-e": () => this.editor.commands.toggleCode()
};
},
addInputRules() {
return [
markInputRule({
find: inputRegex3,
type: this.type
})
];
},
addPasteRules() {
return [
markPasteRule({
find: pasteRegex,
type: this.type
})
];
}
});
// node_modules/.pnpm/@tiptap+extension-code-block@2.9.1_@tiptap+core@2.9.1_@tiptap+pm@2.9.1__@tiptap+pm@2.9.1/node_modules/@tiptap/extension-code-block/dist/index.js
var backtickInputRegex = /^```([a-z]+)?[\s\n]$/;
var tildeInputRegex = /^~~~([a-z]+)?[\s\n]$/;
var CodeBlock = Node.create({
name: "codeBlock",
addOptions() {
return {
languageClassPrefix: "language-",
exitOnTripleEnter: true,
exitOnArrowDown: true,
defaultLanguage: null,
HTMLAttributes: {}
};
},
content: "text*",
marks: "",
group: "block",
code: true,
defining: true,
addAttributes() {
return {
language: {
default: this.options.defaultLanguage,
parseHTML: (element) => {
var _a;
const { languageClassPrefix } = this.options;
const classNames = [...((_a = element.firstElementChild) === null || _a === void 0 ? void 0 : _a.classList) || []];
const languages = classNames.filter((className) => className.startsWith(languageClassPrefix)).map((className) => className.replace(languageClassPrefix, ""));
const language = languages[0];
if (!language) {
return null;
}
return language;
},
rendered: false
}
};
},
parseHTML() {
return [
{
tag: "pre",
preserveWhitespace: "full"
}
];
},
renderHTML({ node, HTMLAttributes }) {
return [
"pre",
mergeAttributes(this.options.HTMLAttributes, HTMLAttributes),
[
"code",
{
class: node.attrs.language ? this.options.languageClassPrefix + node.attrs.language : null
},
0
]
];
},
addCommands() {
return {
setCodeBlock: (attributes) => ({ commands }) => {
return commands.setNode(this.name, attributes);
},
toggleCodeBlock: (attributes) => ({ commands }) => {
return commands.toggleNode(this.name, "paragraph", attributes);
}
};
},
addKeyboardShortcuts() {
return {
"Mod-Alt-c": () => this.editor.commands.toggleCodeBlock(),
// remove code block when at start of document or code block is empty
Backspace: () => {
const { empty, $anchor } = this.editor.state.selection;
const isAtStart = $anchor.pos === 1;
if (!empty || $anchor.parent.type.name !== this.name) {
return false;
}
if (isAtStart || !$anchor.parent.textContent.length) {
return this.editor.commands.clearNodes();
}
return false;
},
// exit node on triple enter
Enter: ({ editor }) => {
if (!this.options.exitOnTripleEnter) {
return false;
}
const { state } = editor;
const { selection } = state;
const { $from, empty } = selection;
if (!empty || $from.parent.type !== this.type) {
return false;
}
const isAtEnd = $from.parentOffset === $from.parent.nodeSize - 2;
const endsWithDoubleNewline = $from.parent.textContent.endsWith("\n\n");
if (!isAtEnd || !endsWithDoubleNewline) {
return false;
}
return editor.chain().command(({ tr }) => {
tr.delete($from.pos - 2, $from.pos);
return true;
}).exitCode().run();
},
// exit node on arrow down
ArrowDown: ({ editor }) => {
if (!this.options.exitOnArrowDown) {
return false;
}
const { state } = editor;
const { selection, doc } = state;
const { $from, empty } = selection;
if (!empty || $from.parent.type !== this.type) {
return false;
}
const isAtEnd = $from.parentOffset === $from.parent.nodeSize - 2;
if (!isAtEnd) {
return false;
}
const after = $from.after();
if (after === void 0) {
return false;
}
const nodeAfter = doc.nodeAt(after);
if (nodeAfter) {
return editor.commands.command(({ tr }) => {
tr.setSelection(Selection.near(doc.resolve(after)));
return true;
});
}
return editor.commands.exitCode();
}
};
},
addInputRules() {
return [
textblockTypeInputRule({
find: backtickInputRegex,
type: this.type,
getAttributes: (match) => ({
language: match[1]
})
}),
textblockTypeInputRule({
find: tildeInputRegex,
type: this.type,
getAttributes: (match) => ({
language: match[1]
})
})
];
},
addProseMirrorPlugins() {
return [
// this plugin creates a code block for pasted content from VS Code
// we can also detect the copied code language
new Plugin({
key: new PluginKey("codeBlockVSCodeHandler"),
props: {
handlePaste: (view, event) => {
if (!event.clipboardData) {
return false;
}
if (this.editor.isActive(this.type.name)) {
return false;
}
const text = event.clipboardData.getData("text/plain");
const vscode = event.clipboardData.getData("vscode-editor-data");
const vscodeData = vscode ? JSON.parse(vscode) : void 0;
const language = vscodeData === null || vscodeData === void 0 ? void 0 : vscodeData.mode;
if (!text || !language) {
return false;
}
const { tr, schema } = view.state;
const textNode = schema.text(text.replace(/\r\n?/g, "\n"));
tr.replaceSelectionWith(this.type.create({ language }, textNode));
if (tr.selection.$from.parent.type !== this.type) {
tr.setSelection(TextSelection.near(tr.doc.resolve(Math.max(0, tr.selection.from - 2))));
}
tr.setMeta("paste", true);
view.dispatch(tr);
return true;
}
}
})
];
}
});
// node_modules/.pnpm/@tiptap+extension-document@2.9.1_@tiptap+core@2.9.1_@tiptap+pm@2.9.1_/node_modules/@tiptap/extension-document/dist/index.js
var Document = Node.create({
name: "doc",
topNode: true,
content: "block+"
});
// node_modules/.pnpm/prosemirror-dropcursor@1.8.1/node_modules/prosemirror-dropcursor/dist/index.js
function dropCursor(options = {}) {
return new Plugin({
view(editorView) {
return new DropCursorView(editorView, options);
}
});
}
var DropCursorView = class {
constructor(editorView, options) {
var _a;
this.editorView = editorView;
this.cursorPos = null;
this.element = null;
this.timeout = -1;
this.width = (_a = options.width) !== null && _a !== void 0 ? _a : 1;
this.color = options.color === false ? void 0 : options.color || "black";
this.class = options.class;
this.handlers = ["dragover", "dragend", "drop", "dragleave"].map((name) => {
let handler = (e) => {
this[name](e);
};
editorView.dom.addEventListener(name, handler);
return { name, handler };
});
}
destroy() {
this.handlers.forEach(({ name, handler }) => this.editorView.dom.removeEventListener(name, handler));
}
update(editorView, prevState) {
if (this.cursorPos != null && prevState.doc != editorView.state.doc) {
if (this.cursorPos > editorView.state.doc.content.size)
this.setCursor(null);
else
this.updateOverlay();
}
}
setCursor(pos) {
if (pos == this.cursorPos)
return;
this.cursorPos = pos;
if (pos == null) {
this.element.parentNode.removeChild(this.element);
this.element = null;
} else {
this.updateOverlay();
}
}
updateOverlay() {
let $pos = this.editorView.state.doc.resolve(this.cursorPos);
let isBlock = !$pos.parent.inlineContent, rect;
if (isBlock) {
let before = $pos.nodeBefore, after = $pos.nodeAfter;
if (before || after) {
let node = this.editorView.nodeDOM(this.cursorPos - (before ? before.nodeSize : 0));
if (node) {
let nodeRect = node.getBoundingClientRect();
let top = before ? nodeRect.bottom : nodeRect.top;
if (before && after)
top = (top + this.editorView.nodeDOM(this.cursorPos).getBoundingClientRect().top) / 2;
rect = { left: nodeRect.left, right: nodeRect.right, top: top - this.width / 2, bottom: top + this.width / 2 };
}
}
}
if (!rect) {
let coords = this.editorView.coordsAtPos(this.cursorPos);
rect = { left: coords.left - this.width / 2, right: coords.left + this.width / 2, top: coords.top, bottom: coords.bottom };
}
let parent = this.editorView.dom.offsetParent;
if (!this.element) {
this.element = parent.appendChild(document.createElement("div"));
if (this.class)
this.element.className = this.class;
this.element.style.cssText = "position: absolute; z-index: 50; pointer-events: none;";
if (this.color) {
this.element.style.backgroundColor = this.color;
}
}
this.element.classList.toggle("prosemirror-dropcursor-block", isBlock);
this.element.classList.toggle("prosemirror-dropcursor-inline", !isBlock);
let parentLeft, parentTop;
if (!parent || parent == document.body && getComputedStyle(parent).position == "static") {
parentLeft = -pageXOffset;
parentTop = -pageYOffset;
} else {
let rect2 = parent.getBoundingClientRect();
parentLeft = rect2.left - parent.scrollLeft;
parentTop = rect2.top - parent.scrollTop;
}
this.element.style.left = rect.left - parentLeft + "px";
this.element.style.top = rect.top - parentTop + "px";
this.element.style.width = rect.right - rect.left + "px";
this.element.style.height = rect.bottom - rect.top + "px";
}
scheduleRemoval(timeout) {
clearTimeout(this.timeout);
this.timeout = setTimeout(() => this.setCursor(null), timeout);
}
dragover(event) {
if (!this.editorView.editable)
return;
let pos = this.editorView.posAtCoords({ left: event.clientX, top: event.clientY });
let node = pos && pos.inside >= 0 && this.editorView.state.doc.nodeAt(pos.inside);
let disableDropCursor = node && node.type.spec.disableDropCursor;
let disabled = typeof disableDropCursor == "function" ? disableDropCursor(this.editorView, pos, event) : disableDropCursor;
if (pos && !disabled) {
let target = pos.pos;
if (this.editorView.dragging && this.editorView.dragging.slice) {
let point = dropPoint(this.editorView.state.doc, target, this.editorView.dragging.slice);
if (point != null)
target = point;
}
this.setCursor(target);
this.scheduleRemoval(5e3);
}
}
dragend() {
this.scheduleRemoval(20);
}
drop() {
this.scheduleRemoval(20);
}
dragleave(event) {
if (event.target == this.editorView.dom || !this.editorView.dom.contains(event.relatedTarget))
this.setCursor(null);
}
};
// node_modules/.pnpm/@tiptap+extension-dropcursor@2.9.1_@tiptap+core@2.9.1_@tiptap+pm@2.9.1__@tiptap+pm@2.9.1/node_modules/@tiptap/extension-dropcursor/dist/index.js
var Dropcursor = Extension.create({
name: "dropCursor",
addOptions() {
return {
color: "currentColor",
width: 1,
class: void 0
};
},
addProseMirrorPlugins() {
return [
dropCursor(this.options)
];
}
});
// node_modules/.pnpm/prosemirror-gapcursor@1.3.2/node_modules/prosemirror-gapcursor/dist/index.js
var GapCursor = class _GapCursor extends Selection {
/**
Create a gap cursor.
*/
constructor($pos) {
super($pos, $pos);
}
map(doc, mapping) {
let $pos = doc.resolve(mapping.map(this.head));
return _GapCursor.valid($pos) ? new _GapCursor($pos) : Selection.near($pos);
}
content() {
return Slice.empty;
}
eq(other) {
return other instanceof _GapCursor && other.head == this.head;
}
toJSON() {
return { type: "gapcursor", pos: this.head };
}
/**
@internal
*/
static fromJSON(doc, json) {
if (typeof json.pos != "number")
throw new RangeError("Invalid input for GapCursor.fromJSON");
return new _GapCursor(doc.resolve(json.pos));
}
/**
@internal
*/
getBookmark() {
return new GapBookmark(this.anchor);
}
/**
@internal
*/
static valid($pos) {
let parent = $pos.parent;
if (parent.isTextblock || !closedBefore($pos) || !closedAfter($pos))
return false;
let override = parent.type.spec.allowGapCursor;
if (override != null)
return override;
let deflt = parent.contentMatchAt($pos.index()).defaultType;
return deflt && deflt.isTextblock;
}
/**
@internal
*/
static findGapCursorFrom($pos, dir, mustMove = false) {
search: for (; ; ) {
if (!mustMove && _GapCursor.valid($pos))
return $pos;
let pos = $pos.pos, next = null;
for (let d = $pos.depth; ; d--) {
let parent = $pos.node(d);
if (dir > 0 ? $pos.indexAfter(d) < parent.childCount : $pos.index(d) > 0) {
next = parent.child(dir > 0 ? $pos.indexAfter(d) : $pos.index(d) - 1);
break;
} else if (d == 0) {
return null;
}
pos += dir;
let $cur = $pos.doc.resolve(pos);
if (_GapCursor.valid($cur))
return $cur;
}
for (; ; ) {
let inside = dir > 0 ? next.firstChild : next.lastChild;
if (!inside) {
if (next.isAtom && !next.isText && !NodeSelection.isSelectable(next)) {
$pos = $pos.doc.resolve(pos + next.nodeSize * dir);
mustMove = false;
continue search;
}
break;
}
next = inside;
pos += dir;
let $cur = $pos.doc.resolve(pos);
if (_GapCursor.valid($cur))
return $cur;
}
return null;
}
}
};
GapCursor.prototype.visible = false;
GapCursor.findFrom = GapCursor.findGapCursorFrom;
Selection.jsonID("gapcursor", GapCursor);
var GapBookmark = class _GapBookmark {
constructor(pos) {
this.pos = pos;
}
map(mapping) {
return new _GapBookmark(mapping.map(this.pos));
}
resolve(doc) {
let $pos = doc.resolve(this.pos);
return GapCursor.valid($pos) ? new GapCursor($pos) : Selection.near($pos);
}
};
function closedBefore($pos) {
for (let d = $pos.depth; d >= 0; d--) {
let index = $pos.index(d), parent = $pos.node(d);
if (index == 0) {
if (parent.type.spec.isolating)
return true;
continue;
}
for (let before = parent.child(index - 1); ; before = before.lastChild) {
if (before.childCount == 0 && !before.inlineContent || before.isAtom || before.type.spec.isolating)
return true;
if (before.inlineContent)
return false;
}
}
return true;
}
function closedAfter($pos) {
for (let d = $pos.depth; d >= 0; d--) {
let index = $pos.indexAfter(d), parent = $pos.node(d);
if (index == parent.childCount) {
if (parent.type.spec.isolating)
return true;
continue;
}
for (let after = parent.child(index); ; after = after.firstChild) {
if (after.childCount == 0 && !after.inlineContent || after.isAtom || after.type.spec.isolating)
return true;
if (after.inlineContent)
return false;
}
}
return true;
}
function gapCursor() {
return new Plugin({
props: {
decorations: drawGapCursor,
createSelectionBetween(_view, $anchor, $head) {
return $anchor.pos == $head.pos && GapCursor.valid($head) ? new GapCursor($head) : null;
},
handleClick,
handleKeyDown,
handleDOMEvents: { beforeinput }
}
});
}
var handleKeyDown = keydownHandler({
"ArrowLeft": arrow("horiz", -1),
"ArrowRight": arrow("horiz", 1),
"ArrowUp": arrow("vert", -1),
"ArrowDown": arrow("vert", 1)
});
function arrow(axis, dir) {
const dirStr = axis == "vert" ? dir > 0 ? "down" : "up" : dir > 0 ? "right" : "left";
return function(state, dispatch, view) {
let sel = state.selection;
let $start = dir > 0 ? sel.$to : sel.$from, mustMove = sel.empty;
if (sel instanceof TextSelection) {
if (!view.endOfTextblock(dirStr) || $start.depth == 0)
return false;
mustMove = false;
$start = state.doc.resolve(dir > 0 ? $start.after() : $start.before());
}
let $found = GapCursor.findGapCursorFrom($start, dir, mustMove);
if (!$found)
return false;
if (dispatch)
dispatch(state.tr.setSelection(new GapCursor($found)));
return true;
};
}
function handleClick(view, pos, event) {
if (!view || !view.editable)
return false;
let $pos = view.state.doc.resolve(pos);
if (!GapCursor.valid($pos))
return false;
let clickPos = view.posAtCoords({ left: event.clientX, top: event.clientY });
if (clickPos && clickPos.inside > -1 && NodeSelection.isSelectable(view.state.doc.nodeAt(clickPos.inside)))
return false;
view.dispatch(view.state.tr.setSelection(new GapCursor($pos)));
return true;
}
function beforeinput(view, event) {
if (event.inputType != "insertCompositionText" || !(view.state.selection instanceof GapCursor))
return false;
let { $from } = view.state.selection;
let insert = $from.parent.contentMatchAt($from.index()).findWrapping(view.state.schema.nodes.text);
if (!insert)
return false;
let frag = Fragment.empty;
for (let i = insert.length - 1; i >= 0; i--)
frag = Fragment.from(insert[i].createAndFill(null, frag));
let tr = view.state.tr.replace($from.pos, $from.pos, new Slice(frag, 0, 0));
tr.setSelection(TextSelection.near(tr.doc.resolve($from.pos + 1)));
view.dispatch(tr);
return false;
}
function drawGapCursor(state) {
if (!(state.selection instanceof GapCursor))
return null;
let node = document.createElement("div");
node.className = "ProseMirror-gapcursor";
return DecorationSet.create(state.doc, [Decoration.widget(state.selection.head, node, { key: "gapcursor" })]);
}
// node_modules/.pnpm/@tiptap+extension-gapcursor@2.9.1_@tiptap+core@2.9.1_@tiptap+pm@2.9.1__@tiptap+pm@2.9.1/node_modules/@tiptap/extension-gapcursor/dist/index.js
var Gapcursor = Extension.create({
name: "gapCursor",
addProseMirrorPlugins() {
return [
gapCursor()
];
},
extendNodeSchema(extension) {
var _a;
const context = {
name: extension.name,
options: extension.options,
storage: extension.storage
};
return {
allowGapCursor: (_a = callOrReturn(getExtensionField(extension, "allowGapCursor", context))) !== null && _a !== void 0 ? _a : null
};
}
});
// node_modules/.pnpm/@tiptap+extension-hard-break@2.9.1_@tiptap+core@2.9.1_@tiptap+pm@2.9.1_/node_modules/@tiptap/extension-hard-break/dist/index.js
var HardBreak = Node.create({
name: "hardBreak",
addOptions() {
return {
keepMarks: true,
HTMLAttributes: {}
};
},
inline: true,
group: "inline",
selectable: false,
parseHTML() {
return [
{ tag: "br" }
];
},
renderHTML({ HTMLAttributes }) {
return ["br", mergeAttributes(this.options.HTMLAttributes, HTMLAttributes)];
},
renderText() {
return "\n";
},
addCommands() {
return {
setHardBreak: () => ({ commands, chain, state, editor }) => {
return commands.first([
() => commands.exitCode(),
() => commands.command(() => {
const { selection, storedMarks } = state;
if (selection.$from.parent.type.spec.isolating) {
return false;
}
const { keepMarks } = this.options;
const { splittableMarks } = editor.extensionManager;
const marks = storedMarks || selection.$to.parentOffset && selection.$from.marks();
return chain().insertContent({ type: this.name }).command(({ tr, dispatch }) => {
if (dispatch && marks && keepMarks) {
const filteredMarks = marks.filter((mark) => splittableMarks.includes(mark.type.name));
tr.ensureMarks(filteredMarks);
}
return true;
}).run();
})
]);
}
};
},
addKeyboardShortcuts() {
return {
"Mod-Enter": () => this.editor.commands.setHardBreak(),
"Shift-Enter": () => this.editor.commands.setHardBreak()
};
}
});
// node_modules/.pnpm/@tiptap+extension-heading@2.9.1_@tiptap+core@2.9.1_@tiptap+pm@2.9.1_/node_modules/@tiptap/extension-heading/dist/index.js
var Heading = Node.create({
name: "heading",
addOptions() {
return {
levels: [1, 2, 3, 4, 5, 6],
HTMLAttributes: {}
};
},
content: "inline*",
group: "block",
defining: true,
addAttributes() {
return {
level: {
default: 1,
rendered: false
}
};
},
parseHTML() {
return this.options.levels.map((level) => ({
tag: `h${level}`,
attrs: { level }
}));
},
renderHTML({ node, HTMLAttributes }) {
const hasLevel = this.options.levels.includes(node.attrs.level);
const level = hasLevel ? node.attrs.level : this.options.levels[0];
return [`h${level}`, mergeAttributes(this.options.HTMLAttributes, HTMLAttributes), 0];
},
addCommands() {
return {
setHeading: (attributes) => ({ commands }) => {
if (!this.options.levels.includes(attributes.level)) {
return false;
}
return commands.setNode(this.name, attributes);
},
toggleHeading: (attributes) => ({ commands }) => {
if (!this.options.levels.includes(attributes.level)) {
return false;
}
return commands.toggleNode(this.name, "paragraph", attributes);
}
};
},
addKeyboardShortcuts() {
return this.options.levels.reduce((items, level) => ({
...items,
...{
[`Mod-Alt-${level}`]: () => this.editor.commands.toggleHeading({ level })
}
}), {});
},
addInputRules() {
return this.options.levels.map((level) => {
return textblockTypeInputRule({
find: new RegExp(`^(#{1,${level}})\\s$`),
type: this.type,
getAttributes: {
level
}
});
});
}
});
// node_modules/.pnpm/rope-sequence@1.3.4/node_modules/rope-sequence/dist/index.js
var GOOD_LEAF_SIZE = 200;
var RopeSequence = function RopeSequence2() {
};
RopeSequence.prototype.append = function append(other) {
if (!other.length) {
return this;
}
other = RopeSequence.from(other);
return !this.length && other || other.length < GOOD_LEAF_SIZE && this.leafAppend(other) || this.length < GOOD_LEAF_SIZE && other.leafPrepend(this) || this.appendInner(other);
};
RopeSequence.prototype.prepend = function prepend(other) {
if (!other.length) {
return this;
}
return RopeSequence.from(other).append(this);
};
RopeSequence.prototype.appendInner = function appendInner(other) {
return new Append(this, other);
};
RopeSequence.prototype.slice = function slice(from2, to) {
if (from2 === void 0) from2 = 0;
if (to === void 0) to = this.length;
if (from2 >= to) {
return RopeSequence.empty;
}
return this.sliceInner(Math.max(0, from2), Math.min(this.length, to));
};
RopeSequence.prototype.get = function get(i) {
if (i < 0 || i >= this.length) {
return void 0;
}
return this.getInner(i);
};
RopeSequence.prototype.forEach = function forEach(f, from2, to) {
if (from2 === void 0) from2 = 0;
if (to === void 0) to = this.length;
if (from2 <= to) {
this.forEachInner(f, from2, to, 0);
} else {
this.forEachInvertedInner(f, from2, to, 0);
}
};
RopeSequence.prototype.map = function map(f, from2, to) {
if (from2 === void 0) from2 = 0;
if (to === void 0) to = this.length;
var result = [];
this.forEach(function(elt, i) {
return result.push(f(elt, i));
}, from2, to);
return result;
};
RopeSequence.from = function from(values) {
if (values instanceof RopeSequence) {
return values;
}
return values && values.length ? new Leaf(values) : RopeSequence.empty;
};
var Leaf = /* @__PURE__ */ function(RopeSequence3) {
function Leaf2(values) {
RopeSequence3.call(this);
this.values = values;
}
if (RopeSequence3) Leaf2.__proto__ = RopeSequence3;
Leaf2.prototype = Object.create(RopeSequence3 && RopeSequence3.prototype);
Leaf2.prototype.constructor = Leaf2;
var prototypeAccessors = { length: { configurable: true }, depth: { configurable: true } };
Leaf2.prototype.flatten = function flatten() {
return this.values;
};
Leaf2.prototype.sliceInner = function sliceInner(from2, to) {
if (from2 == 0 && to == this.length) {
return this;
}
return new Leaf2(this.values.slice(from2, to));
};
Leaf2.prototype.getInner = function getInner(i) {
return this.values[i];
};
Leaf2.prototype.forEachInner = function forEachInner(f, from2, to, start) {
for (var i = from2; i < to; i++) {
if (f(this.values[i], start + i) === false) {
return false;
}
}
};
Leaf2.prototype.forEachInvertedInner = function forEachInvertedInner(f, from2, to, start) {
for (var i = from2 - 1; i >= to; i--) {
if (f(this.values[i], start + i) === false) {
return false;
}
}
};
Leaf2.prototype.leafAppend = function leafAppend(other) {
if (this.length + other.length <= GOOD_LEAF_SIZE) {
return new Leaf2(this.values.concat(other.flatten()));
}
};
Leaf2.prototype.leafPrepend = function leafPrepend(other) {
if (this.length + other.length <= GOOD_LEAF_SIZE) {
return new Leaf2(other.flatten().concat(this.values));
}
};
prototypeAccessors.length.get = function() {
return this.values.length;
};
prototypeAccessors.depth.get = function() {
return 0;
};
Object.defineProperties(Leaf2.prototype, prototypeAccessors);
return Leaf2;
}(RopeSequence);
RopeSequence.empty = new Leaf([]);
var Append = /* @__PURE__ */ function(RopeSequence3) {
function Append2(left, right) {
RopeSequence3.call(this);
this.left = left;
this.right = right;
this.length = left.length + right.length;
this.depth = Math.max(left.depth, right.depth) + 1;
}
if (RopeSequence3) Append2.__proto__ = RopeSequence3;
Append2.prototype = Object.create(RopeSequence3 && RopeSequence3.prototype);
Append2.prototype.constructor = Append2;
Append2.prototype.flatten = function flatten() {
return this.left.flatten().concat(this.right.flatten());
};
Append2.prototype.getInner = function getInner(i) {
return i < this.left.length ? this.left.get(i) : this.right.get(i - this.left.length);
};
Append2.prototype.forEachInner = function forEachInner(f, from2, to, start) {
var leftLen = this.left.length;
if (from2 < leftLen && this.left.forEachInner(f, from2, Math.min(to, leftLen), start) === false) {
return false;
}
if (to > leftLen && this.right.forEachInner(f, Math.max(from2 - leftLen, 0), Math.min(this.length, to) - leftLen, start + leftLen) === false) {
return false;
}
};
Append2.prototype.forEachInvertedInner = function forEachInvertedInner(f, from2, to, start) {
var leftLen = this.left.length;
if (from2 > leftLen && this.right.forEachInvertedInner(f, from2 - leftLen, Math.max(to, leftLen) - leftLen, start + leftLen) === false) {
return false;
}
if (to < leftLen && this.left.forEachInvertedInner(f, Math.min(from2, leftLen), to, start) === false) {
return false;
}
};
Append2.prototype.sliceInner = function sliceInner(from2, to) {
if (from2 == 0 && to == this.length) {
return this;
}
var leftLen = this.left.length;
if (to <= leftLen) {
return this.left.slice(from2, to);
}
if (from2 >= leftLen) {
return this.right.slice(from2 - leftLen, to - leftLen);
}
return this.left.slice(from2, leftLen).append(this.right.slice(0, to - leftLen));
};
Append2.prototype.leafAppend = function leafAppend(other) {
var inner = this.right.leafAppend(other);
if (inner) {
return new Append2(this.left, inner);
}
};
Append2.prototype.leafPrepend = function leafPrepend(other) {
var inner = this.left.leafPrepend(other);
if (inner) {
return new Append2(inner, this.right);
}
};
Append2.prototype.appendInner = function appendInner2(other) {
if (this.left.depth >= Math.max(this.right.depth, other.depth) + 1) {
return new Append2(this.left, new Append2(this.right, other));
}
return new Append2(this, other);
};
return Append2;
}(RopeSequence);
var dist_default = RopeSequence;
// node_modules/.pnpm/prosemirror-history@1.4.1/node_modules/prosemirror-history/dist/index.js
var max_empty_items = 500;
var Branch = class _Branch {
constructor(items, eventCount) {
this.items = items;
this.eventCount = eventCount;
}
// Pop the latest event off the branch's history and apply it
// to a document transform.
popEvent(state, preserveItems) {
if (this.eventCount == 0)
return null;
let end = this.items.length;
for (; ; end--) {
let next = this.items.get(end - 1);
if (next.selection) {
--end;
break;
}
}
let remap, mapFrom;
if (preserveItems) {
remap = this.remapping(end, this.items.length);
mapFrom = remap.maps.length;
}
let transform = state.tr;
let selection, remaining;
let addAfter = [], addBefore = [];
this.items.forEach((item, i) => {
if (!item.step) {
if (!remap) {
remap = this.remapping(end, i + 1);
mapFrom = remap.maps.length;
}
mapFrom--;
addBefore.push(item);
return;
}
if (remap) {
addBefore.push(new Item(item.map));
let step = item.step.map(remap.slice(mapFrom)), map2;
if (step && transform.maybeStep(step).doc) {
map2 = transform.mapping.maps[transform.mapping.maps.length - 1];
addAfter.push(new Item(map2, void 0, void 0, addAfter.length + addBefore.length));
}
mapFrom--;
if (map2)
remap.appendMap(map2, mapFrom);
} else {
transform.maybeStep(item.step);
}
if (item.selection) {
selection = remap ? item.selection.map(remap.slice(mapFrom)) : item.selection;
remaining = new _Branch(this.items.slice(0, end).append(addBefore.reverse().concat(addAfter)), this.eventCount - 1);
return false;
}
}, this.items.length, 0);
return { remaining, transform, selection };
}
// Create a new branch with the given transform added.
addTransform(transform, selection, histOptions, preserveItems) {
let newItems = [], eventCount = this.eventCount;
let oldItems = this.items, lastItem = !preserveItems && oldItems.length ? oldItems.get(oldItems.length - 1) : null;
for (let i = 0; i < transform.steps.length; i++) {
let step = transform.steps[i].invert(transform.docs[i]);
let item = new Item(transform.mapping.maps[i], step, selection), merged;
if (merged = lastItem && lastItem.merge(item)) {
item = merged;
if (i)
newItems.pop();
else
oldItems = oldItems.slice(0, oldItems.length - 1);
}
newItems.push(item);
if (selection) {
eventCount++;
selection = void 0;
}
if (!preserveItems)
lastItem = item;
}
let overflow = eventCount - histOptions.depth;
if (overflow > DEPTH_OVERFLOW) {
oldItems = cutOffEvents(oldItems, overflow);
eventCount -= overflow;
}
return new _Branch(oldItems.append(newItems), eventCount);
}
remapping(from2, to) {
let maps = new Mapping();
this.items.forEach((item, i) => {
let mirrorPos = item.mirrorOffset != null && i - item.mirrorOffset >= from2 ? maps.maps.length - item.mirrorOffset : void 0;
maps.appendMap(item.map, mirrorPos);
}, from2, to);
return maps;
}
addMaps(array) {
if (this.eventCount == 0)
return this;
return new _Branch(this.items.append(array.map((map2) => new Item(map2))), this.eventCount);
}
// When the collab module receives remote changes, the history has
// to know about those, so that it can adjust the steps that were
// rebased on top of the remote changes, and include the position
// maps for the remote changes in its array of items.
rebased(rebasedTransform, rebasedCount) {
if (!this.eventCount)
return this;
let rebasedItems = [], start = Math.max(0, this.items.length - rebasedCount);
let mapping = rebasedTransform.mapping;
let newUntil = rebasedTransform.steps.length;
let eventCount = this.eventCount;
this.items.forEach((item) => {
if (item.selection)
eventCount--;
}, start);
let iRebased = rebasedCount;
this.items.forEach((item) => {
let pos = mapping.getMirror(--iRebased);
if (pos == null)
return;
newUntil = Math.min(newUntil, pos);
let map2 = mapping.maps[pos];
if (item.step) {
let step = rebasedTransform.steps[pos].invert(rebasedTransform.docs[pos]);
let selection = item.selection && item.selection.map(mapping.slice(iRebased + 1, pos));
if (selection)
eventCount++;
rebasedItems.push(new Item(map2, step, selection));
} else {
rebasedItems.push(new Item(map2));
}
}, start);
let newMaps = [];
for (let i = rebasedCount; i < newUntil; i++)
newMaps.push(new Item(mapping.maps[i]));
let items = this.items.slice(0, start).append(newMaps).append(rebasedItems);
let branch = new _Branch(items, eventCount);
if (branch.emptyItemCount() > max_empty_items)
branch = branch.compress(this.items.length - rebasedItems.length);
return branch;
}
emptyItemCount() {
let count = 0;
this.items.forEach((item) => {
if (!item.step)
count++;
});
return count;
}
// Compressing a branch means rewriting it to push the air (map-only
// items) out. During collaboration, these naturally accumulate
// because each remote change adds one. The `upto` argument is used
// to ensure that only the items below a given level are compressed,
// because `rebased` relies on a clean, untouched set of items in
// order to associate old items with rebased steps.
compress(upto = this.items.length) {
let remap = this.remapping(0, upto), mapFrom = remap.maps.length;
let items = [], events = 0;
this.items.forEach((item, i) => {
if (i >= upto) {
items.push(item);
if (item.selection)
events++;
} else if (item.step) {
let step = item.step.map(remap.slice(mapFrom)), map2 = step && step.getMap();
mapFrom--;
if (map2)
remap.appendMap(map2, mapFrom);
if (step) {
let selection = item.selection && item.selection.map(remap.slice(mapFrom));
if (selection)
events++;
let newItem = new Item(map2.invert(), step, selection), merged, last = items.length - 1;
if (merged = items.length && items[last].merge(newItem))
items[last] = merged;
else
items.push(newItem);
}
} else if (item.map) {
mapFrom--;
}
}, this.items.length, 0);
return new _Branch(dist_default.from(items.reverse()), events);
}
};
Branch.empty = new Branch(dist_default.empty, 0);
function cutOffEvents(items, n) {
let cutPoint;
items.forEach((item, i) => {
if (item.selection && n-- == 0) {
cutPoint = i;
return false;
}
});
return items.slice(cutPoint);
}
var Item = class _Item {
constructor(map2, step, selection, mirrorOffset) {
this.map = map2;
this.step = step;
this.selection = selection;
this.mirrorOffset = mirrorOffset;
}
merge(other) {
if (this.step && other.step && !other.selection) {
let step = other.step.merge(this.step);
if (step)
return new _Item(step.getMap().invert(), step, this.selection);
}
}
};
var HistoryState = class {
constructor(done, undone, prevRanges, prevTime, prevComposition) {
this.done = done;
this.undone = undone;
this.prevRanges = prevRanges;
this.prevTime = prevTime;
this.prevComposition = prevComposition;
}
};
var DEPTH_OVERFLOW = 20;
function applyTransaction(history2, state, tr, options) {
let historyTr = tr.getMeta(historyKey), rebased;
if (historyTr)
return historyTr.historyState;
if (tr.getMeta(closeHistoryKey))
history2 = new HistoryState(history2.done, history2.undone, null, 0, -1);
let appended = tr.getMeta("appendedTransaction");
if (tr.steps.length == 0) {
return history2;
} else if (appended && appended.getMeta(historyKey)) {
if (appended.getMeta(historyKey).redo)
return new HistoryState(history2.done.addTransform(tr, void 0, options, mustPreserveItems(state)), history2.undone, rangesFor(tr.mapping.maps), history2.prevTime, history2.prevComposition);
else
return new HistoryState(history2.done, history2.undone.addTransform(tr, void 0, options, mustPreserveItems(state)), null, history2.prevTime, history2.prevComposition);
} else if (tr.getMeta("addToHistory") !== false && !(appended && appended.getMeta("addToHistory") === false)) {
let composition = tr.getMeta("composition");
let newGroup = history2.prevTime == 0 || !appended && history2.prevComposition != composition && (history2.prevTime < (tr.time || 0) - options.newGroupDelay || !isAdjacentTo(tr, history2.prevRanges));
let prevRanges = appended ? mapRanges(history2.prevRanges, tr.mapping) : rangesFor(tr.mapping.maps);
return new HistoryState(history2.done.addTransform(tr, newGroup ? state.selection.getBookmark() : void 0, options, mustPreserveItems(state)), Branch.empty, prevRanges, tr.time, composition == null ? history2.prevComposition : composition);
} else if (rebased = tr.getMeta("rebased")) {
return new HistoryState(history2.done.rebased(tr, rebased), history2.undone.rebased(tr, rebased), mapRanges(history2.prevRanges, tr.mapping), history2.prevTime, history2.prevComposition);
} else {
return new HistoryState(history2.done.addMaps(tr.mapping.maps), history2.undone.addMaps(tr.mapping.maps), mapRanges(history2.prevRanges, tr.mapping), history2.prevTime, history2.prevComposition);
}
}
function isAdjacentTo(transform, prevRanges) {
if (!prevRanges)
return false;
if (!transform.docChanged)
return true;
let adjacent = false;
transform.mapping.maps[0].forEach((start, end) => {
for (let i = 0; i < prevRanges.length; i += 2)
if (start <= prevRanges[i + 1] && end >= prevRanges[i])
adjacent = true;
});
return adjacent;
}
function rangesFor(maps) {
let result = [];
for (let i = maps.length - 1; i >= 0 && result.length == 0; i--)
maps[i].forEach((_from, _to, from2, to) => result.push(from2, to));
return result;
}
function mapRanges(ranges, mapping) {
if (!ranges)
return null;
let result = [];
for (let i = 0; i < ranges.length; i += 2) {
let from2 = mapping.map(ranges[i], 1), to = mapping.map(ranges[i + 1], -1);
if (from2 <= to)
result.push(from2, to);
}
return result;
}
function histTransaction(history2, state, redo2) {
let preserveItems = mustPreserveItems(state);
let histOptions = historyKey.get(state).spec.config;
let pop = (redo2 ? history2.undone : history2.done).popEvent(state, preserveItems);
if (!pop)
return null;
let selection = pop.selection.resolve(pop.transform.doc);
let added = (redo2 ? history2.done : history2.undone).addTransform(pop.transform, state.selection.getBookmark(), histOptions, preserveItems);
let newHist = new HistoryState(redo2 ? added : pop.remaining, redo2 ? pop.remaining : added, null, 0, -1);
return pop.transform.setSelection(selection).setMeta(historyKey, { redo: redo2, historyState: newHist });
}
var cachedPreserveItems = false;
var cachedPreserveItemsPlugins = null;
function mustPreserveItems(state) {
let plugins = state.plugins;
if (cachedPreserveItemsPlugins != plugins) {
cachedPreserveItems = false;
cachedPreserveItemsPlugins = plugins;
for (let i = 0; i < plugins.length; i++)
if (plugins[i].spec.historyPreserveItems) {
cachedPreserveItems = true;
break;
}
}
return cachedPreserveItems;
}
var historyKey = new PluginKey("history");
var closeHistoryKey = new PluginKey("closeHistory");
function history(config = {}) {
config = {
depth: config.depth || 100,
newGroupDelay: config.newGroupDelay || 500
};
return new Plugin({
key: historyKey,
state: {
init() {
return new HistoryState(Branch.empty, Branch.empty, null, 0, -1);
},
apply(tr, hist, state) {
return applyTransaction(hist, state, tr, config);
}
},
config,
props: {
handleDOMEvents: {
beforeinput(view, e) {
let inputType = e.inputType;
let command = inputType == "historyUndo" ? undo : inputType == "historyRedo" ? redo : null;
if (!command)
return false;
e.preventDefault();
return command(view.state, view.dispatch);
}
}
}
});
}
function buildCommand(redo2, scroll) {
return (state, dispatch) => {
let hist = historyKey.getState(state);
if (!hist || (redo2 ? hist.undone : hist.done).eventCount == 0)
return false;
if (dispatch) {
let tr = histTransaction(hist, state, redo2);
if (tr)
dispatch(scroll ? tr.scrollIntoView() : tr);
}
return true;
};
}
var undo = buildCommand(false, true);
var redo = buildCommand(true, true);
var undoNoScroll = buildCommand(false, false);
var redoNoScroll = buildCommand(true, false);
// node_modules/.pnpm/@tiptap+extension-history@2.9.1_@tiptap+core@2.9.1_@tiptap+pm@2.9.1__@tiptap+pm@2.9.1/node_modules/@tiptap/extension-history/dist/index.js
var History = Extension.create({
name: "history",
addOptions() {
return {
depth: 100,
newGroupDelay: 500
};
},
addCommands() {
return {
undo: () => ({ state, dispatch }) => {
return undo(state, dispatch);
},
redo: () => ({ state, dispatch }) => {
return redo(state, dispatch);
}
};
},
addProseMirrorPlugins() {
return [
history(this.options)
];
},
addKeyboardShortcuts() {
return {
"Mod-z": () => this.editor.commands.undo(),
"Shift-Mod-z": () => this.editor.commands.redo(),
"Mod-y": () => this.editor.commands.redo(),
// Russian keyboard layouts
"Mod-\u044F": () => this.editor.commands.undo(),
"Shift-Mod-\u044F": () => this.editor.commands.redo()
};
}
});
// node_modules/.pnpm/@tiptap+extension-horizontal-rule@2.9.1_@tiptap+core@2.9.1_@tiptap+pm@2.9.1__@tiptap+pm@2.9.1/node_modules/@tiptap/extension-horizontal-rule/dist/index.js
var HorizontalRule = Node.create({
name: "horizontalRule",
addOptions() {
return {
HTMLAttributes: {}
};
},
group: "block",
parseHTML() {
return [{ tag: "hr" }];
},
renderHTML({ HTMLAttributes }) {
return ["hr", mergeAttributes(this.options.HTMLAttributes, HTMLAttributes)];
},
addCommands() {
return {
setHorizontalRule: () => ({ chain, state }) => {
const { selection } = state;
const { $from: $originFrom, $to: $originTo } = selection;
const currentChain = chain();
if ($originFrom.parentOffset === 0) {
currentChain.insertContentAt({
from: Math.max($originFrom.pos - 1, 0),
to: $originTo.pos
}, {
type: this.name
});
} else if (isNodeSelection(selection)) {
currentChain.insertContentAt($originTo.pos, {
type: this.name
});
} else {
currentChain.insertContent({ type: this.name });
}
return currentChain.command(({ tr, dispatch }) => {
var _a;
if (dispatch) {
const { $to } = tr.selection;
const posAfter = $to.end();
if ($to.nodeAfter) {
if ($to.nodeAfter.isTextblock) {
tr.setSelection(TextSelection.create(tr.doc, $to.pos + 1));
} else if ($to.nodeAfter.isBlock) {
tr.setSelection(NodeSelection.create(tr.doc, $to.pos));
} else {
tr.setSelection(TextSelection.create(tr.doc, $to.pos));
}
} else {
const node = (_a = $to.parent.type.contentMatch.defaultType) === null || _a === void 0 ? void 0 : _a.create();
if (node) {
tr.insert(posAfter, node);
tr.setSelection(TextSelection.create(tr.doc, posAfter + 1));
}
}
tr.scrollIntoView();
}
return true;
}).run();
}
};
},
addInputRules() {
return [
nodeInputRule({
find: /^(?:---|—-|___\s|\*\*\*\s)$/,
type: this.type
})
];
}
});
// node_modules/.pnpm/@tiptap+extension-italic@2.9.1_@tiptap+core@2.9.1_@tiptap+pm@2.9.1_/node_modules/@tiptap/extension-italic/dist/index.js
var starInputRegex2 = /(?:^|\s)(\*(?!\s+\*)((?:[^*]+))\*(?!\s+\*))$/;
var starPasteRegex2 = /(?:^|\s)(\*(?!\s+\*)((?:[^*]+))\*(?!\s+\*))/g;
var underscoreInputRegex2 = /(?:^|\s)(_(?!\s+_)((?:[^_]+))_(?!\s+_))$/;
var underscorePasteRegex2 = /(?:^|\s)(_(?!\s+_)((?:[^_]+))_(?!\s+_))/g;
var Italic = Mark.create({
name: "italic",
addOptions() {
return {
HTMLAttributes: {}
};
},
parseHTML() {
return [
{
tag: "em"
},
{
tag: "i",
getAttrs: (node) => node.style.fontStyle !== "normal" && null
},
{
style: "font-style=normal",
clearMark: (mark) => mark.type.name === this.name
},
{
style: "font-style=italic"
}
];
},
renderHTML({ HTMLAttributes }) {
return ["em", mergeAttributes(this.options.HTMLAttributes, HTMLAttributes), 0];
},
addCommands() {
return {
setItalic: () => ({ commands }) => {
return commands.setMark(this.name);
},
toggleItalic: () => ({ commands }) => {
return commands.toggleMark(this.name);
},
unsetItalic: () => ({ commands }) => {
return commands.unsetMark(this.name);
}
};
},
addKeyboardShortcuts() {
return {
"Mod-i": () => this.editor.commands.toggleItalic(),
"Mod-I": () => this.editor.commands.toggleItalic()
};
},
addInputRules() {
return [
markInputRule({
find: starInputRegex2,
type: this.type
}),
markInputRule({
find: underscoreInputRegex2,
type: this.type
})
];
},
addPasteRules() {
return [
markPasteRule({
find: starPasteRegex2,
type: this.type
}),
markPasteRule({
find: underscorePasteRegex2,
type: this.type
})
];
}
});
// node_modules/.pnpm/@tiptap+extension-list-item@2.9.1_@tiptap+core@2.9.1_@tiptap+pm@2.9.1_/node_modules/@tiptap/extension-list-item/dist/index.js
var ListItem = Node.create({
name: "listItem",
addOptions() {
return {
HTMLAttributes: {},
bulletListTypeName: "bulletList",
orderedListTypeName: "orderedList"
};
},
content: "paragraph block*",
defining: true,
parseHTML() {
return [
{
tag: "li"
}
];
},
renderHTML({ HTMLAttributes }) {
return ["li", mergeAttributes(this.options.HTMLAttributes, HTMLAttributes), 0];
},
addKeyboardShortcuts() {
return {
Enter: () => this.editor.commands.splitListItem(this.name),
Tab: () => this.editor.commands.sinkListItem(this.name),
"Shift-Tab": () => this.editor.commands.liftListItem(this.name)
};
}
});
// node_modules/.pnpm/@tiptap+extension-ordered-list@2.9.1_@tiptap+core@2.9.1_@tiptap+pm@2.9.1_/node_modules/@tiptap/extension-ordered-list/dist/index.js
var ListItemName2 = "listItem";
var TextStyleName2 = "textStyle";
var inputRegex4 = /^(\d+)\.\s$/;
var OrderedList = Node.create({
name: "orderedList",
addOptions() {
return {
itemTypeName: "listItem",
HTMLAttributes: {},
keepMarks: false,
keepAttributes: false
};
},
group: "block list",
content() {
return `${this.options.itemTypeName}+`;
},
addAttributes() {
return {
start: {
default: 1,
parseHTML: (element) => {
return element.hasAttribute("start") ? parseInt(element.getAttribute("start") || "", 10) : 1;
}
},
type: {
default: void 0,
parseHTML: (element) => element.getAttribute("type")
}
};
},
parseHTML() {
return [
{
tag: "ol"
}
];
},
renderHTML({ HTMLAttributes }) {
const { start, ...attributesWithoutStart } = HTMLAttributes;
return start === 1 ? ["ol", mergeAttributes(this.options.HTMLAttributes, attributesWithoutStart), 0] : ["ol", mergeAttributes(this.options.HTMLAttributes, HTMLAttributes), 0];
},
addCommands() {
return {
toggleOrderedList: () => ({ commands, chain }) => {
if (this.options.keepAttributes) {
return chain().toggleList(this.name, this.options.itemTypeName, this.options.keepMarks).updateAttributes(ListItemName2, this.editor.getAttributes(TextStyleName2)).run();
}
return commands.toggleList(this.name, this.options.itemTypeName, this.options.keepMarks);
}
};
},
addKeyboardShortcuts() {
return {
"Mod-Shift-7": () => this.editor.commands.toggleOrderedList()
};
},
addInputRules() {
let inputRule = wrappingInputRule({
find: inputRegex4,
type: this.type,
getAttributes: (match) => ({ start: +match[1] }),
joinPredicate: (match, node) => node.childCount + node.attrs.start === +match[1]
});
if (this.options.keepMarks || this.options.keepAttributes) {
inputRule = wrappingInputRule({
find: inputRegex4,
type: this.type,
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],
editor: this.editor
});
}
return [
inputRule
];
}
});
// node_modules/.pnpm/@tiptap+extension-paragraph@2.9.1_@tiptap+core@2.9.1_@tiptap+pm@2.9.1_/node_modules/@tiptap/extension-paragraph/dist/index.js
var Paragraph = Node.create({
name: "paragraph",
priority: 1e3,
addOptions() {
return {
HTMLAttributes: {}
};
},
group: "block",
content: "inline*",
parseHTML() {
return [
{ tag: "p" }
];
},
renderHTML({ HTMLAttributes }) {
return ["p", mergeAttributes(this.options.HTMLAttributes, HTMLAttributes), 0];
},
addCommands() {
return {
setParagraph: () => ({ commands }) => {
return commands.setNode(this.name);
}
};
},
addKeyboardShortcuts() {
return {
"Mod-Alt-0": () => this.editor.commands.setParagraph()
};
}
});
// node_modules/.pnpm/@tiptap+extension-text@2.9.1_@tiptap+core@2.9.1_@tiptap+pm@2.9.1_/node_modules/@tiptap/extension-text/dist/index.js
var Text = Node.create({
name: "text",
group: "inline"
});
// node_modules/.pnpm/@tiptap+starter-kit@2.9.1/node_modules/@tiptap/starter-kit/dist/index.js
var StarterKit = Extension.create({
name: "starterKit",
addExtensions() {
var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t;
const extensions = [];
if (this.options.bold !== false) {
extensions.push(Bold.configure((_a = this.options) === null || _a === void 0 ? void 0 : _a.bold));
}
if (this.options.blockquote !== false) {
extensions.push(Blockquote.configure((_b = this.options) === null || _b === void 0 ? void 0 : _b.blockquote));
}
if (this.options.bulletList !== false) {
extensions.push(BulletList.configure((_c = this.options) === null || _c === void 0 ? void 0 : _c.bulletList));
}
if (this.options.code !== false) {
extensions.push(Code.configure((_d = this.options) === null || _d === void 0 ? void 0 : _d.code));
}
if (this.options.codeBlock !== false) {
extensions.push(CodeBlock.configure((_e = this.options) === null || _e === void 0 ? void 0 : _e.codeBlock));
}
if (this.options.document !== false) {
extensions.push(Document.configure((_f = this.options) === null || _f === void 0 ? void 0 : _f.document));
}
if (this.options.dropcursor !== false) {
extensions.push(Dropcursor.configure((_g = this.options) === null || _g === void 0 ? void 0 : _g.dropcursor));
}
if (this.options.gapcursor !== false) {
extensions.push(Gapcursor.configure((_h = this.options) === null || _h === void 0 ? void 0 : _h.gapcursor));
}
if (this.options.hardBreak !== false) {
extensions.push(HardBreak.configure((_j = this.options) === null || _j === void 0 ? void 0 : _j.hardBreak));
}
if (this.options.heading !== false) {
extensions.push(Heading.configure((_k = this.options) === null || _k === void 0 ? void 0 : _k.heading));
}
if (this.options.history !== false) {
extensions.push(History.configure((_l = this.options) === null || _l === void 0 ? void 0 : _l.history));
}
if (this.options.horizontalRule !== false) {
extensions.push(HorizontalRule.configure((_m = this.options) === null || _m === void 0 ? void 0 : _m.horizontalRule));
}
if (this.options.italic !== false) {
extensions.push(Italic.configure((_o = this.options) === null || _o === void 0 ? void 0 : _o.italic));
}
if (this.options.listItem !== false) {
extensions.push(ListItem.configure((_p = this.options) === null || _p === void 0 ? void 0 : _p.listItem));
}
if (this.options.orderedList !== false) {
extensions.push(OrderedList.configure((_q = this.options) === null || _q === void 0 ? void 0 : _q.orderedList));
}
if (this.options.paragraph !== false) {
extensions.push(Paragraph.configure((_r = this.options) === null || _r === void 0 ? void 0 : _r.paragraph));
}
if (this.options.strike !== false) {
extensions.push(Strike.configure((_s = this.options) === null || _s === void 0 ? void 0 : _s.strike));
}
if (this.options.text !== false) {
extensions.push(Text.configure((_t = this.options) === null || _t === void 0 ? void 0 : _t.text));
}
return extensions;
}
});
// src/exports/elements/tip-tap-editor-base.ts
var TipTapEditorBase = class extends BaseElement {
constructor() {
super();
// Instance
/**
* Whether or not the editor should be editable.
*
* NOTE: a user can change this in the browser dev tools, don't rely on this to prevent
* users from editing and attempting to save the document.
*/
this.readonly = false;
/**
* Prevents premature rebuilds.
*/
this.hasInitialized = false;
/**
* An array of "AttachmentUploads" added via direct upload. Check this for any attachment uploads that have not completed.
*/
this.pendingAttachments = [];
/**
* JSON or HTML serializer used for determining the string to write to the hidden input.
*/
this.serializer = "html";
/** Comma separated string passed to the attach-files input. */
this.accept = "*";
this.starterKitOptions = {
// We don't use the native strike since it requires configuring ActionText.
strike: false,
rhinoLink: {
openOnClick: false
}
};
/**
* This will be concatenated onto RhinoStarterKit and StarterKit extensions.
*/
this.extensions = [];
/**
* When the `defer-initialize` attribute is present, it will wait to start the TipTap editor until the attribute has been removed.
*/
this.deferInitialize = false;
/**
* @internal
*/
this.__initialAttributes = {};
/**
* @internal
*/
this.__hasRendered = false;
this.__initializationPromise__ = null;
this.__initializationResolver__ = null;
/**
* Used for determining how to handle uploads.
* Override this for substituting your own
* direct upload functionality.
*/
this.handleAttachment = (event) => {
setTimeout(() => {
if (event.defaultPrevented) {
return;
}
const { attachment, target } = event;
if (target instanceof HTMLElement && attachment.file) {
const upload = new AttachmentUpload(attachment, target);
upload.start();
}
});
};
/** Override this to prevent specific file types from being uploaded. */
this.handleFileAccept = (_event) => {
};
this.handleDropFile = (_view, event, _slice, moved) => {
if (!(event instanceof DragEvent)) return false;
if (moved) return false;
return this.handleNativeDrop(event);
};
this.handlePaste = async (event) => {
if (this.editor == null) return;
if (event == null) return;
const { clipboardData } = event;
if (clipboardData == null) return;
let string = false;
const hasFiles = clipboardData.files?.length > 0;
let attachments = [];
if (hasFiles) {
attachments = await this.handleFiles(clipboardData.files);
} else {
let dataType = "text/plain";
if (clipboardData.types.includes("text/html")) {
dataType = "text/html";
}
string = clipboardData.getData(dataType);
}
setTimeout(async () => {
if (event.defaultPrevented || event.originalPasteEvent.defaultPrevented) {
return;
}
if (string !== false) {
this.editor?.chain().focus().insertContent(string).run();
return;
}
if (attachments.length > 0) {
this.editor?.chain().focus().setAttachment(attachments).run();
return;
}
});
};
this.__handleCreate = () => {
this.requestUpdate();
};
this.__handleUpdate = () => {
this.requestUpdate();
if (!this.hasInitialized) {
return;
}
this.updateInputElementValue();
this.dispatchEvent(new RhinoChangeEvent());
};
this.__handleFocus = () => {
this.dispatchEvent(new RhinoFocusEvent());
this.requestUpdate();
};
this.__handleBlur = () => {
this.updateInputElementValue();
this.requestUpdate();
this.dispatchEvent(new RhinoBlurEvent());
};
this.__handleSelectionUpdate = ({
transaction
}) => {
this.requestUpdate();
this.dispatchEvent(new SelectionChangeEvent({ transaction }));
};
this.__handleTransaction = () => {
this.requestUpdate();
};
this.__addPendingAttachment = this.__addPendingAttachment.bind(this);
this.__removePendingAttachment = this.__removePendingAttachment.bind(this);
this.registerDependencies();
this.addEventListener(AddAttachmentEvent.eventName, this.handleAttachment);
this.addEventListener(
AttachmentUploadStartEvent.eventName,
this.__addPendingAttachment
);
this.addEventListener(
AttachmentUploadCompleteEvent.eventName,
this.__removePendingAttachment
);
this.addEventListener(
AttachmentRemoveEvent.eventName,
this.__removePendingAttachment
);
this.addEventListener("drop", this.handleNativeDrop);
this.addEventListener("rhino-paste", this.handlePaste);
this.addEventListener("rhino-file-accept", this.handleFileAccept);
}
static get styles() {
return [normalize, tipTapCoreStyles, editor_default];
}
static get properties() {
return {
// Attributes
readonly: { type: Boolean, reflect: true },
input: { reflect: true },
class: { reflect: true },
accept: { reflect: true },
serializer: { reflect: true },
deferInitialize: {
type: Boolean,
attribute: "defer-initialize",
reflect: true
},
// Properties
editor: { state: true },
editorElement: { state: true },
starterKitOptions: { state: true },
extensions: { state: true }
};
}
__getInitialAttributes() {
if (this.__hasRendered) return;
const slottedEditor = this.slottedEditor;
if (slottedEditor) {
this.__initialAttributes = {};
[...slottedEditor.attributes].forEach((attr) => {
const { nodeName, nodeValue } = attr;
if (nodeName && nodeValue != null) {
this.__initialAttributes[nodeName] = nodeValue;
}
});
}
this.__hasRendered = true;
}
/**
* Reset mechanism. This is called on first connect, and called anytime extensions,
* or editor options get modified to make sure we have a fresh instance.
*/
rebuildEditor() {
if (!this.hasInitialized) return;
const editors = this.querySelectorAll("[slot='editor']");
this.__getInitialAttributes();
if (this.editor) {
this.editor.destroy();
}
editors.forEach((el) => {
el.editor?.destroy();
el.remove();
});
this.editor = this.__setupEditor(this);
this.__bindEditorListeners();
this.editorElement = this.querySelector(".ProseMirror");
Object.entries(this.__initialAttributes)?.forEach(
([attrName, attrValue]) => {
if (attrName === "class") {
this.editorElement?.classList.add(...attrValue.split(" "));
return;
}
this.editorElement?.setAttribute(attrName, attrValue);
}
);
this.editorElement?.setAttribute("slot", "editor");
this.editorElement?.classList.add("trix-content");
this.editorElement?.setAttribute("tabindex", "0");
this.editorElement?.setAttribute("role", "textbox");
this.requestUpdate();
}
/**
* Grabs HTML content based on a given range. If no range is given, it will return the contents
* of the current editor selection. If the current selection is empty, it will return an empty string.
* @param from - The start of the selection
* @param to - The end of the selection
* @example Getting the HTML content of the current selection
* const rhinoEditor = document.querySelector("rhino-editor")
* rhinoEditor.getHTMLContentFromRange()
*
* @example Getting the HTML content of node range
* const rhinoEditor = document.querySelector("rhino-editor")
* rhinoEditor.getHTMLContentFromRange(0, 50)
*
* @example Getting the HTML content and falling back to entire editor HTML
* const rhinoEditor = document.querySelector("rhino-editor")
* let html = rhinoEditor.getHTMLContentFromRange()
* if (!html) {
* html = rhinoEditor.editor.getHTML()
* }
*/
getHTMLContentFromRange(from2, to) {
const editor = this.editor;
if (!editor) return "";
let empty;
if (!from2 && !to) {
const currentSelection = editor.state.selection;
from2 = currentSelection.from;
to = currentSelection.to;
}
if (empty) {
return "";
}
if (from2 == null) {
return "";
}
if (to == null) {
return "";
}
const { state } = editor;
const htmlArray = [];
const tempScript = document.createElement("script");
tempScript.type = "text/plain";
state.doc.nodesBetween(from2, to, (node, _pos, parent) => {
if (parent === state.doc) {
tempScript.innerHTML = "";
const serializer = DOMSerializer.fromSchema(editor.schema);
const dom = serializer.serializeNode(node);
tempScript.appendChild(dom);
htmlArray.push(tempScript.innerHTML);
tempScript.innerHTML = "";
}
});
return htmlArray.join("");
}
/**
* Grabs plain text representation based on a given range. If no parameters are given, it will return the contents
* of the current selection. If the current selection is empty, it will return an empty string.
* @param from - The start of the selection
* @param to - The end of the selection
* @example Getting the Text content of the current selection
* const rhinoEditor = document.querySelector("rhino-editor")
* rhinoEditor.getTextContentFromRange()
*
* @example Getting the Text content of node range
* const rhinoEditor = document.querySelector("rhino-editor")
* rhinoEditor.getTextContentFromRange(0, 50)
*
* @example Getting the Text content and falling back to entire editor Text
* const rhinoEditor = document.querySelector("rhino-editor")
* let text = rhinoEditor.getTextContentFromRange()
* if (!text) {
* text = rhinoEditor.editor.getText()
* }
*/
getTextContentFromRange(from2, to) {
const editor = this.editor;
if (!editor) {
return "";
}
let empty;
if (!from2 && !to) {
const selection = editor.state.selection;
from2 = selection.from;
to = selection.to;
empty = selection.empty;
}
if (empty) {
return "";
}
if (from2 == null) {
return "";
}
if (to == null) {
return "";
}
return editor.state.doc.textBetween(from2, to, " ");
}
willUpdate(changedProperties) {
if (changedProperties.has("deferInitialize") && !this.deferInitialize) {
this.startEditor();
}
if (changedProperties.has("class")) {
this.classList.add("rhino-editor");
}
super.willUpdate(changedProperties);
}
updated(changedProperties) {
if (!this.hasInitialized) {
return super.updated(changedProperties);
}
if (changedProperties.has("readonly")) {
this.editor?.setEditable(!this.readonly);
}
if (changedProperties.has("extensions") || changedProperties.has("serializer") || changedProperties.has("starterKitOptions") || changedProperties.has("translations")) {
this.rebuildEditor();
}
if (changedProperties.has("serializer")) {
this.updateInputElementValue();
}
super.updated(changedProperties);
this.dispatchEvent(
new Event("rhino-update", {
bubbles: true,
composed: true,
cancelable: false
})
);
}
/** Used for registering things like <role-toolbar>, <role-tooltip>, <rhino-attachment-editor> */
registerDependencies() {
[AttachmentEditor].forEach((el) => el.define());
}
get slottedEditor() {
return this.querySelector("[slot='editor']");
}
/**
* @private
*/
__addPendingAttachment(e) {
this.pendingAttachments.push(e.attachmentUpload);
}
/**
* @private
*/
__removePendingAttachment(e) {
const index = this.pendingAttachments.findIndex((attachment) => {
if ("attachmentUpload" in e) {
return attachment === e.attachmentUpload;
}
if ("attachment" in e) {
return attachment.attachment.attachmentId === e.attachment.attachmentId;
}
return false;
});
if (index > -1) {
this.pendingAttachments.splice(index, 1);
}
}
async connectedCallback() {
super.connectedCallback();
this.__setupInitialization__();
if (this.editor) {
this.__unBindEditorListeners();
}
this.classList.add("rhino-editor");
if (!this.deferInitialize) {
this.startEditor();
}
}
async startEditor() {
await this.updateComplete;
setTimeout(() => {
this.dispatchEvent(new BeforeInitializeEvent());
setTimeout(async () => {
await this.updateComplete;
this.hasInitialized = true;
this.rebuildEditor();
this.dispatchEvent(new InitializeEvent());
this.__initializationResolver__?.();
});
});
}
disconnectedCallback() {
super.disconnectedCallback();
this.editor?.destroy();
this.hasInitialized = false;
this.__initializationPromise__ = null;
this.__initializationResolver__ = null;
}
__setupInitialization__() {
if (!this.__initializationPromise__) {
this.__initializationPromise__ = new Promise((resolve) => {
this.__initializationResolver__ = resolve;
});
}
}
get initializationComplete() {
this.__setupInitialization__();
return this.__initializationPromise__;
}
addExtensions(...extensions) {
let ary = [];
extensions.forEach((ext) => {
if (Array.isArray(ext)) {
ary = ary.concat(ext.flat(1));
return;
}
ary.push(ext);
});
const existingExtensions = this.extensions.map((ext) => ext.name);
ary = ary.filter((ext) => {
return !existingExtensions.includes(ext.name);
});
this.extensions = this.extensions.concat(ary);
}
disableStarterKitOptions(...options) {
const disabledStarterKitOptions = {};
options.forEach((ext) => {
if (Array.isArray(ext)) {
ext.flat(1).forEach((str) => disabledStarterKitOptions[str] = false);
return;
}
disabledStarterKitOptions[ext] = false;
});
this.starterKitOptions = {
...this.starterKitOptions,
...disabledStarterKitOptions
};
}
/**
* Extend this to provide your own options, or override existing options.
* The "element" is where the editor will be initialized.
* This will be merged
* @example
* class ExtendedRhinoEditor extends TipTapEditor {
* editorOptions (_element: Element) {
* return {
* autofocus: true
* }
* }
* }
*
*/
editorOptions(_element) {
return {};
}
/**
* Finds the <input> element in the light dom and updates it with the value of `#serialize()`
*/
updateInputElementValue() {
if (this.inputElement != null && this.editor != null && !this.readonly) {
this.inputElement.value = this.serialize();
}
}
/**
* Function called when grabbing the content of the editor. Currently supports JSON or HTML.
*/
serialize() {
if (this.editor == null) return "";
if (this.serializer?.toLowerCase() === "json") {
return JSON.stringify(this.editor.getJSON());
}
return this.editor.getHTML();
}
/**
* Searches for the <input> element in the light dom to write the HTML or JSON to.
*/
get inputElement() {
if (!this.input) return void 0;
const rootNode = this.getRootNode() || document;
return rootNode.querySelector(`#${this.input}`);
}
async handleFiles(files) {
if (this.editor == null) return [];
if (files == null) return [];
return new Promise((resolve, _reject) => {
const fileAcceptEvents = [...files].map((file) => {
const event = new FileAcceptEvent(file);
this.dispatchEvent(event);
return event;
});
const allowedFiles = [];
for (let i = 0; i < fileAcceptEvents.length; i++) {
const event = fileAcceptEvents[i];
if (event.defaultPrevented) {
continue;
}
allowedFiles.push(event.file);
}
const attachments = this.transformFilesToAttachments(allowedFiles);
if (attachments == null || attachments.length <= 0) return;
attachments.forEach((attachment) => {
this.dispatchEvent(new AddAttachmentEvent(attachment));
});
resolve(attachments);
});
}
/**
* Handles dropped files on the component, but not on the prosemirror instance.
*/
handleNativeDrop(event) {
if (this.editor == null) return false;
if (event == null) return false;
const { dataTransfer } = event;
if (dataTransfer == null) return false;
if (dataTransfer.files.length <= 0) return false;
if (event.defaultPrevented) return false;
event.preventDefault();
this.handleFiles(dataTransfer.files).then((attachments) => {
this.editor?.chain().focus().setAttachmentAtCoords(attachments, {
top: event.clientY,
left: event.clientX
}).run();
});
return true;
}
transformFilesToAttachments(files) {
if (this.editor == null) return;
if (files == null || files.length === 0) return;
const attachments = [];
for (let i = 0; i < files.length; i++) {
const file = files[i];
if (file == null) return;
const src = URL.createObjectURL(file);
const attachment = new AttachmentManager(
{
src,
file
},
this.editor.view
);
attachments.push(attachment);
}
return attachments;
}
renderToolbar() {
return ke``;
}
renderDialog() {
return ke``;
}
render() {
return ke`
${this.renderToolbar()}
<div class="editor-wrapper" part="editor-wrapper">
${this.renderDialog()}
<div class="editor" part="editor">
<slot name="editor">
<div class="trix-content"></div>
</slot>
</div>
</div>
`;
}
allOptions(element) {
return {
...this.__defaultOptions(element),
...this.editorOptions(element)
};
}
/**
* Due to some inconsistencies in how Trix will render the inputElement based on if its
* the HTML representation, or transfromed with `#to_trix_html` this gives
* us a consistent DOM structure to parse for rich text comments.
*/
normalizeDOM(inputElement, parser = new DOMParser()) {
if (inputElement == null || inputElement.value == null) return;
const doc = parser.parseFromString(inputElement.value, "text/html");
const figures = [...doc.querySelectorAll("figure[data-trix-attachment]")];
const filtersWithoutChildren = figures.filter(
(figure) => figure.querySelector("figcaption") == null
);
doc.querySelectorAll("div > figure:first-child").forEach((el) => {
el.parentElement?.classList.add("attachment-gallery");
});
filtersWithoutChildren.forEach((figure) => {
const attrs = figure.getAttribute("data-trix-attributes");
if (!attrs) return;
const { caption } = JSON.parse(attrs);
if (caption) {
figure.insertAdjacentHTML(
"beforeend",
`<figcaption class="attachment__caption">${caption}</figcaption>`
);
return;
}
});
doc.querySelectorAll(
"figure :not(.attachment__caption--edited) .attachment__name"
).forEach((el) => {
if (el.textContent?.includes(" \xB7 ") === false) return;
el.insertAdjacentText("beforeend", " \xB7 ");
});
const body = doc.querySelector("body");
if (body) {
inputElement.value = body.innerHTML;
}
}
/**
* @private
* Use a getter here so when we rebuild the editor it pulls the latest starterKitOptions
* This is intentionally not to be configured by a user. It makes updating extensions hard.
* it also is a getter and not a variable so that it will rerun in case options change.
*/
get __starterKitExtensions__() {
return [
StarterKit.configure(this.starterKitOptions),
RhinoStarterKit.configure(this.starterKitOptions)
];
}
/**
* @param {Element} element - The element that the editor will be installed onto.
*/
__defaultOptions(element) {
let content = this.inputElement?.value || "";
if (content) {
try {
content = JSON.parse(content);
} catch (e) {
}
}
const extensions = this.__starterKitExtensions__.concat(this.extensions);
return {
injectCSS: false,
extensions,
autofocus: false,
element,
content,
editable: !this.readonly,
editorProps: {
handleDrop: this.handleDropFile
}
};
}
__bindEditorListeners() {
if (this.editor == null) return;
this.editor.on("focus", this.__handleFocus);
this.editor.on("create", this.__handleCreate);
this.editor.on("update", this.__handleUpdate);
this.editor.on("selectionUpdate", this.__handleSelectionUpdate);
this.editor.on("transaction", this.__handleTransaction);
this.editor.on("blur", this.__handleBlur);
}
__unBindEditorListeners() {
if (this.editor == null) return;
this.editor.off("focus", this.__handleFocus);
this.editor.off("create", this.__handleCreate);
this.editor.off("update", this.__handleUpdate);
this.editor.off("selectionUpdate", this.__handleSelectionUpdate);
this.editor.off("transaction", this.__handleTransaction);
this.editor.off("blur", this.__handleBlur);
}
__setupEditor(element = this) {
if (!this.serializer || this.serializer === "html") {
this.normalizeDOM(this.inputElement);
}
const editor = new Editor(this.allOptions(element));
return editor;
}
};
// Static
/**
* Default registration name
*/
TipTapEditorBase.baseName = "rhino-editor";
export {
TipTapEditorBase
};
//# sourceMappingURL=chunk-OEHUOIM2.js.map