@quoreadmin/ui 1.10.10 → 1.10.11

package/dist/index281.js

@@ -1,44 +1,12 @@
-import { Node as o, mergeAttributes as i } from "./index270.js";
-var a = " ", d = " ", p = o.create({
-  name: "paragraph",
-  priority: 1e3,
-  addOptions() {
-    return {
-      HTMLAttributes: {}
-    };
-  },
-  group: "block",
-  content: "inline*",
-  parseHTML() {
-    return [{ tag: "p" }];
-  },
-  renderHTML({ HTMLAttributes: r }) {
-    return ["p", i(this.options.HTMLAttributes, r), 0];
-  },
-  parseMarkdown: (r, e) => {
-    const t = r.tokens || [];
-    if (t.length === 1 && t[0].type === "image")
-      return e.parseChildren([t[0]]);
-    const n = e.parseInline(t);
-    return n.length === 1 && n[0].type === "text" && (n[0].text === a || n[0].text === d) ? e.createNode("paragraph", void 0, []) : e.createNode("paragraph", void 0, n);
-  },
-  renderMarkdown: (r, e) => {
-    if (!r)
-      return "";
-    const t = Array.isArray(r.content) ? r.content : [];
-    return t.length === 0 ? a : e.renderChildren(t);
-  },
-  addCommands() {
-    return {
-      setParagraph: () => ({ commands: r }) => r.setNode(this.name)
-    };
-  },
-  addKeyboardShortcuts() {
-    return {
-      "Mod-Alt-0": () => this.editor.commands.setParagraph()
-    };
-  }
+import { Node as n } from "./index276.js";
+var o = n.create({
+  name: "doc",
+  topNode: !0,
+  content: "block+",
+  renderMarkdown: (e, r) => e.content ? r.renderChildren(e.content, `
+
+`) : ""
 });
 export {
-  p as Paragraph
+  o as Document
 };

package/dist/index282.js

@@ -1,66 +1,59 @@
-import { Mark as r, markPasteRule as s, markInputRule as n, mergeAttributes as a } from "./index270.js";
-var i = /(?:^|\s)(~~(?!\s+~~)((?:[^~]+))~~(?!\s+~~))$/, d = /(?:^|\s)(~~(?!\s+~~)((?:[^~]+))~~(?!\s+~~))/g, o = r.create({
-  name: "strike",
+import { Node as l, mergeAttributes as c } from "./index276.js";
+var f = l.create({
+  name: "hardBreak",
+  markdownTokenName: "br",
   addOptions() {
     return {
+      keepMarks: !0,
       HTMLAttributes: {}
     };
   },
+  inline: !0,
+  group: "inline",
+  selectable: !1,
+  linebreakReplacement: !0,
   parseHTML() {
-    return [
-      {
-        tag: "s"
-      },
-      {
-        tag: "del"
-      },
-      {
-        tag: "strike"
-      },
-      {
-        style: "text-decoration",
-        consuming: !1,
-        getAttrs: (e) => e.includes("line-through") ? {} : !1
-      }
-    ];
+    return [{ tag: "br" }];
   },
   renderHTML({ HTMLAttributes: e }) {
-    return ["s", a(this.options.HTMLAttributes, e), 0];
+    return ["br", c(this.options.HTMLAttributes, e)];
   },
-  markdownTokenName: "del",
-  parseMarkdown: (e, t) => t.applyMark("strike", t.parseInline(e.tokens || [])),
-  renderMarkdown: (e, t) => `~~${t.renderChildren(e)}~~`,
+  renderText() {
+    return `
+`;
+  },
+  renderMarkdown: () => `  
+`,
+  parseMarkdown: () => ({
+    type: "hardBreak"
+  }),
   addCommands() {
     return {
-      setStrike: () => ({ commands: e }) => e.setMark(this.name),
-      toggleStrike: () => ({ commands: e }) => e.toggleMark(this.name),
-      unsetStrike: () => ({ commands: e }) => e.unsetMark(this.name)
+      setHardBreak: () => ({ commands: e, chain: n, state: a, editor: s }) => e.first([
+        () => e.exitCode(),
+        () => e.command(() => {
+          const { selection: r, storedMarks: o } = a;
+          if (r.$from.parent.type.spec.isolating)
+            return !1;
+          const { keepMarks: i } = this.options, { splittableMarks: d } = s.extensionManager, t = o || r.$to.parentOffset && r.$from.marks();
+          return n().insertContent({ type: this.name }).command(({ tr: u, dispatch: k }) => {
+            if (k && t && i) {
+              const m = t.filter((p) => d.includes(p.type.name));
+              u.ensureMarks(m);
+            }
+            return !0;
+          }).run();
+        })
+      ])
     };
   },
   addKeyboardShortcuts() {
     return {
-      "Mod-Shift-s": () => this.editor.commands.toggleStrike()
+      "Mod-Enter": () => this.editor.commands.setHardBreak(),
+      "Shift-Enter": () => this.editor.commands.setHardBreak()
     };
-  },
-  addInputRules() {
-    return [
-      n({
-        find: i,
-        type: this.type
-      })
-    ];
-  },
-  addPasteRules() {
-    return [
-      s({
-        find: d,
-        type: this.type
-      })
-    ];
   }
 });
 export {
-  o as Strike,
-  i as inputRegex,
-  d as pasteRegex
+  f as HardBreak
 };

package/dist/index283.js

@@ -1,13 +1,63 @@
-import { Node as t } from "./index270.js";
-var o = t.create({
-  name: "text",
-  group: "inline",
-  parseMarkdown: (e) => ({
-    type: "text",
-    text: e.text || ""
-  }),
-  renderMarkdown: (e) => e.text || ""
+import { Node as l, textblockTypeInputRule as i, mergeAttributes as a } from "./index276.js";
+var d = l.create({
+  name: "heading",
+  addOptions() {
+    return {
+      levels: [1, 2, 3, 4, 5, 6],
+      HTMLAttributes: {}
+    };
+  },
+  content: "inline*",
+  group: "block",
+  defining: !0,
+  addAttributes() {
+    return {
+      level: {
+        default: 1,
+        rendered: !1
+      }
+    };
+  },
+  parseHTML() {
+    return this.options.levels.map((e) => ({
+      tag: `h${e}`,
+      attrs: { level: e }
+    }));
+  },
+  renderHTML({ node: e, HTMLAttributes: t }) {
+    return [`h${this.options.levels.includes(e.attrs.level) ? e.attrs.level : this.options.levels[0]}`, a(this.options.HTMLAttributes, t), 0];
+  },
+  parseMarkdown: (e, t) => t.createNode("heading", { level: e.depth || 1 }, t.parseInline(e.tokens || [])),
+  renderMarkdown: (e, t) => {
+    var r;
+    const n = (r = e.attrs) != null && r.level ? parseInt(e.attrs.level, 10) : 1, s = "#".repeat(n);
+    return e.content ? `${s} ${t.renderChildren(e.content)}` : "";
+  },
+  addCommands() {
+    return {
+      setHeading: (e) => ({ commands: t }) => this.options.levels.includes(e.level) ? t.setNode(this.name, e) : !1,
+      toggleHeading: (e) => ({ commands: t }) => this.options.levels.includes(e.level) ? t.toggleNode(this.name, "paragraph", e) : !1
+    };
+  },
+  addKeyboardShortcuts() {
+    return this.options.levels.reduce(
+      (e, t) => ({
+        ...e,
+        [`Mod-Alt-${t}`]: () => this.editor.commands.toggleHeading({ level: t })
+      }),
+      {}
+    );
+  },
+  addInputRules() {
+    return this.options.levels.map((e) => i({
+      find: new RegExp(`^(#{${Math.min(...this.options.levels)},${e}})\\s$`),
+      type: this.type,
+      getAttributes: {
+        level: e
+      }
+    }));
+  }
 });
 export {
-  o as Text
+  d as Heading
 };