@quoreadmin/ui 1.10.3 → 1.10.5

package/dist/index250.js

@@ -1,57 +1,56 @@
-import { Node as a, wrappingInputRule as c, mergeAttributes as d } from "./index249.js";
-import { createElement as i } from "./index307.js";
-var l = /^\s*>\s$/, g = a.create({
-  name: "blockquote",
+import { Node as m, nodeInputRule as f, canInsertNode as h, isNodeSelection as T, mergeAttributes as y } from "./index242.js";
+import { TextSelection as s, NodeSelection as N } from "./index257.js";
+var M = m.create({
+  name: "horizontalRule",
   addOptions() {
     return {
-      HTMLAttributes: {}
+      HTMLAttributes: {},
+      nextNodeType: "paragraph"
     };
   },
-  content: "block+",
   group: "block",
-  defining: !0,
   parseHTML() {
-    return [{ tag: "blockquote" }];
+    return [{ tag: "hr" }];
   },
-  renderHTML({ HTMLAttributes: t }) {
-    return /* @__PURE__ */ i("blockquote", { ...d(this.options.HTMLAttributes, t), children: /* @__PURE__ */ i("slot", {}) });
-  },
-  parseMarkdown: (t, e) => e.createNode("blockquote", void 0, e.parseChildren(t.tokens || [])),
-  renderMarkdown: (t, e) => {
-    if (!t.content)
-      return "";
-    const r = ">", n = [];
-    return t.content.forEach((u) => {
-      const s = e.renderChildren([u]).split(`
-`).map((o) => o.trim() === "" ? r : `${r} ${o}`);
-      n.push(s.join(`
-`));
-    }), n.join(`
-${r}
-`);
+  renderHTML({ HTMLAttributes: n }) {
+    return ["hr", y(this.options.HTMLAttributes, n)];
   },
+  markdownTokenName: "hr",
+  parseMarkdown: (n, o) => o.createNode("horizontalRule"),
+  renderMarkdown: () => "---",
   addCommands() {
     return {
-      setBlockquote: () => ({ commands: t }) => t.wrapIn(this.name),
-      toggleBlockquote: () => ({ commands: t }) => t.toggleWrap(this.name),
-      unsetBlockquote: () => ({ commands: t }) => t.lift(this.name)
-    };
-  },
-  addKeyboardShortcuts() {
-    return {
-      "Mod-Shift-b": () => this.editor.commands.toggleBlockquote()
+      setHorizontalRule: () => ({ chain: n, state: o }) => {
+        if (!h(o, o.schema.nodes[this.name]))
+          return !1;
+        const { selection: i } = o, { $to: l } = i, r = n();
+        return T(i) ? r.insertContentAt(l.pos, {
+          type: this.name
+        }) : r.insertContent({ type: this.name }), r.command(({ state: p, tr: e, dispatch: u }) => {
+          if (u) {
+            const { $to: t } = e.selection, a = t.end();
+            if (t.nodeAfter)
+              t.nodeAfter.isTextblock ? e.setSelection(s.create(e.doc, t.pos + 1)) : t.nodeAfter.isBlock ? e.setSelection(N.create(e.doc, t.pos)) : e.setSelection(s.create(e.doc, t.pos));
+            else {
+              const c = p.schema.nodes[this.options.nextNodeType] || t.parent.type.contentMatch.defaultType, d = c?.create();
+              d && (e.insert(a, d), e.setSelection(s.create(e.doc, a + 1)));
+            }
+            e.scrollIntoView();
+          }
+          return !0;
+        }).run();
+      }
     };
   },
   addInputRules() {
     return [
-      c({
-        find: l,
+      f({
+        find: /^(?:---|—-|___\s|\*\*\*\s)$/,
         type: this.type
       })
     ];
   }
 });
 export {
-  g as Blockquote,
-  l as inputRegex
+  M as HorizontalRule
 };

package/dist/index251.js

@@ -1,7 +1,6 @@
-import { Mark as a, markPasteRule as r, markInputRule as s, mergeAttributes as o } from "./index249.js";
-import { createElement as n } from "./index307.js";
-var d = /(?:^|\s)(\*\*(?!\s+\*\*)((?:[^*]+))\*\*(?!\s+\*\*))$/, l = /(?:^|\s)(\*\*(?!\s+\*\*)((?:[^*]+))\*\*(?!\s+\*\*))/g, i = /(?:^|\s)(__(?!\s+__)((?:[^_]+))__(?!\s+__))$/, u = /(?:^|\s)(__(?!\s+__)((?:[^_]+))__(?!\s+__))/g, p = a.create({
-  name: "bold",
+import { Mark as s, markPasteRule as r, markInputRule as a, mergeAttributes as n } from "./index242.js";
+var i = /(?:^|\s)(\*(?!\s+\*)((?:[^*]+))\*(?!\s+\*))$/, d = /(?:^|\s)(\*(?!\s+\*)((?:[^*]+))\*(?!\s+\*))/g, o = /(?:^|\s)(_(?!\s+_)((?:[^_]+))_(?!\s+_))$/, l = /(?:^|\s)(_(?!\s+_)((?:[^_]+))_(?!\s+_))/g, m = s.create({
+  name: "italic",
   addOptions() {
     return {
       HTMLAttributes: {}
@@ -10,49 +9,48 @@ var d = /(?:^|\s)(\*\*(?!\s+\*\*)((?:[^*]+))\*\*(?!\s+\*\*))$/, l = /(?:^|\s)(\*
   parseHTML() {
     return [
       {
-        tag: "strong"
+        tag: "em"
       },
       {
-        tag: "b",
-        getAttrs: (t) => t.style.fontWeight !== "normal" && null
+        tag: "i",
+        getAttrs: (t) => t.style.fontStyle !== "normal" && null
       },
       {
-        style: "font-weight=400",
+        style: "font-style=normal",
         clearMark: (t) => t.type.name === this.name
       },
       {
-        style: "font-weight",
-        getAttrs: (t) => /^(bold(er)?|[5-9]\d{2,})$/.test(t) && null
+        style: "font-style=italic"
       }
     ];
   },
   renderHTML({ HTMLAttributes: t }) {
-    return /* @__PURE__ */ n("strong", { ...o(this.options.HTMLAttributes, t), children: /* @__PURE__ */ n("slot", {}) });
+    return ["em", n(this.options.HTMLAttributes, t), 0];
   },
-  markdownTokenName: "strong",
-  parseMarkdown: (t, e) => e.applyMark("bold", e.parseInline(t.tokens || [])),
-  renderMarkdown: (t, e) => `**${e.renderChildren(t)}**`,
   addCommands() {
     return {
-      setBold: () => ({ commands: t }) => t.setMark(this.name),
-      toggleBold: () => ({ commands: t }) => t.toggleMark(this.name),
-      unsetBold: () => ({ commands: t }) => t.unsetMark(this.name)
+      setItalic: () => ({ commands: t }) => t.setMark(this.name),
+      toggleItalic: () => ({ commands: t }) => t.toggleMark(this.name),
+      unsetItalic: () => ({ commands: t }) => t.unsetMark(this.name)
     };
   },
+  markdownTokenName: "em",
+  parseMarkdown: (t, e) => e.applyMark("italic", e.parseInline(t.tokens || [])),
+  renderMarkdown: (t, e) => `*${e.renderChildren(t)}*`,
   addKeyboardShortcuts() {
     return {
-      "Mod-b": () => this.editor.commands.toggleBold(),
-      "Mod-B": () => this.editor.commands.toggleBold()
+      "Mod-i": () => this.editor.commands.toggleItalic(),
+      "Mod-I": () => this.editor.commands.toggleItalic()
     };
   },
   addInputRules() {
     return [
-      s({
-        find: d,
+      a({
+        find: i,
         type: this.type
       }),
-      s({
-        find: i,
+      a({
+        find: o,
         type: this.type
       })
     ];
@@ -60,20 +58,20 @@ var d = /(?:^|\s)(\*\*(?!\s+\*\*)((?:[^*]+))\*\*(?!\s+\*\*))$/, l = /(?:^|\s)(\*
   addPasteRules() {
     return [
       r({
-        find: l,
+        find: d,
         type: this.type
       }),
       r({
-        find: u,
+        find: l,
         type: this.type
       })
     ];
   }
 });
 export {
-  p as Bold,
-  d as starInputRegex,
-  l as starPasteRegex,
-  i as underscoreInputRegex,
-  u as underscorePasteRegex
+  m as Italic,
+  i as starInputRegex,
+  d as starPasteRegex,
+  o as underscoreInputRegex,
+  l as underscorePasteRegex
 };