@quoreadmin/ui 1.10.5 → 1.10.7

package/dist/index253.js

@@ -1,44 +1,217 @@
-import { Node as o, mergeAttributes as i } from "./index242.js";
-var a = " ", d = " ", p = o.create({
-  name: "paragraph",
-  priority: 1e3,
+import { Node as k, textblockTypeInputRule as S, mergeAttributes as C } from "./index249.js";
+import { Plugin as w, PluginKey as B, TextSelection as T, Selection as L } from "./index264.js";
+var y = 4, M = /^```([a-z]+)?[\s\n]$/, N = /^~~~([a-z]+)?[\s\n]$/, $ = k.create({
+  name: "codeBlock",
   addOptions() {
     return {
+      languageClassPrefix: "language-",
+      exitOnTripleEnter: !0,
+      exitOnArrowDown: !0,
+      defaultLanguage: null,
+      enableTabIndentation: !1,
+      tabSize: y,
       HTMLAttributes: {}
     };
   },
+  content: "text*",
+  marks: "",
   group: "block",
-  content: "inline*",
+  code: !0,
+  defining: !0,
+  addAttributes() {
+    return {
+      language: {
+        default: this.options.defaultLanguage,
+        parseHTML: (e) => {
+          var t;
+          const { languageClassPrefix: r } = this.options;
+          if (!r)
+            return null;
+          const o = [...((t = e.firstElementChild) == null ? void 0 : t.classList) || []].filter((s) => s.startsWith(r)).map((s) => s.replace(r, ""))[0];
+          return o || null;
+        },
+        rendered: !1
+      }
+    };
+  },
   parseHTML() {
-    return [{ tag: "p" }];
+    return [
+      {
+        tag: "pre",
+        preserveWhitespace: "full"
+      }
+    ];
   },
-  renderHTML({ HTMLAttributes: r }) {
-    return ["p", i(this.options.HTMLAttributes, r), 0];
+  renderHTML({ node: e, HTMLAttributes: t }) {
+    return [
+      "pre",
+      C(this.options.HTMLAttributes, t),
+      [
+        "code",
+        {
+          class: e.attrs.language ? this.options.languageClassPrefix + e.attrs.language : null
+        },
+        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);
+  markdownTokenName: "code",
+  parseMarkdown: (e, t) => {
+    var r;
+    return ((r = e.raw) == null ? void 0 : r.startsWith("```")) === !1 && e.codeBlockStyle !== "indented" ? [] : t.createNode(
+      "codeBlock",
+      { language: e.lang || null },
+      e.text ? [t.createTextNode(e.text)] : []
+    );
   },
-  renderMarkdown: (r, e) => {
-    if (!r)
-      return "";
-    const t = Array.isArray(r.content) ? r.content : [];
-    return t.length === 0 ? a : e.renderChildren(t);
+  renderMarkdown: (e, t) => {
+    var r;
+    let n = "";
+    const a = ((r = e.attrs) == null ? void 0 : r.language) || "";
+    return e.content ? n = [`\`\`\`${a}`, t.renderChildren(e.content), "```"].join(`
+`) : n = `\`\`\`${a}
+
+\`\`\``, n;
   },
   addCommands() {
     return {
-      setParagraph: () => ({ commands: r }) => r.setNode(this.name)
+      setCodeBlock: (e) => ({ commands: t }) => t.setNode(this.name, e),
+      toggleCodeBlock: (e) => ({ commands: t }) => t.toggleNode(this.name, "paragraph", e)
     };
   },
   addKeyboardShortcuts() {
     return {
-      "Mod-Alt-0": () => this.editor.commands.setParagraph()
+      "Mod-Alt-c": () => this.editor.commands.toggleCodeBlock(),
+      // remove code block when at start of document or code block is empty
+      Backspace: () => {
+        const { empty: e, $anchor: t } = this.editor.state.selection, r = t.pos === 1;
+        return !e || t.parent.type.name !== this.name ? !1 : r || !t.parent.textContent.length ? this.editor.commands.clearNodes() : !1;
+      },
+      // handle tab indentation
+      Tab: ({ editor: e }) => {
+        var t;
+        if (!this.options.enableTabIndentation)
+          return !1;
+        const r = (t = this.options.tabSize) != null ? t : y, { state: n } = e, { selection: a } = n, { $from: o, empty: s } = a;
+        if (o.parent.type !== this.type)
+          return !1;
+        const i = " ".repeat(r);
+        return s ? e.commands.insertContent(i) : e.commands.command(({ tr: l }) => {
+          const { from: c, to: f } = a, u = n.doc.textBetween(c, f, `
+`, `
+`).split(`
+`).map((p) => i + p).join(`
+`);
+          return l.replaceWith(c, f, n.schema.text(u)), !0;
+        });
+      },
+      // handle shift+tab reverse indentation
+      "Shift-Tab": ({ editor: e }) => {
+        var t;
+        if (!this.options.enableTabIndentation)
+          return !1;
+        const r = (t = this.options.tabSize) != null ? t : y, { state: n } = e, { selection: a } = n, { $from: o, empty: s } = a;
+        return o.parent.type !== this.type ? !1 : s ? e.commands.command(({ tr: i }) => {
+          var l;
+          const { pos: c } = o, f = o.start(), h = o.end(), u = n.doc.textBetween(f, h, `
+`, `
+`).split(`
+`);
+          let p = 0, g = 0;
+          const b = c - f;
+          for (let d = 0; d < u.length; d += 1) {
+            if (g + u[d].length >= b) {
+              p = d;
+              break;
+            }
+            g += u[d].length + 1;
+          }
+          const A = ((l = u[p].match(/^ */)) == null ? void 0 : l[0]) || "", v = Math.min(A.length, r);
+          if (v === 0)
+            return !0;
+          let m = f;
+          for (let d = 0; d < p; d += 1)
+            m += u[d].length + 1;
+          return i.delete(m, m + v), c - m <= v && i.setSelection(T.create(i.doc, m)), !0;
+        }) : e.commands.command(({ tr: i }) => {
+          const { from: l, to: c } = a, x = n.doc.textBetween(l, c, `
+`, `
+`).split(`
+`).map((u) => {
+            var p;
+            const g = ((p = u.match(/^ */)) == null ? void 0 : p[0]) || "", b = Math.min(g.length, r);
+            return u.slice(b);
+          }).join(`
+`);
+          return i.replaceWith(l, c, n.schema.text(x)), !0;
+        });
+      },
+      // exit node on triple enter
+      Enter: ({ editor: e }) => {
+        if (!this.options.exitOnTripleEnter)
+          return !1;
+        const { state: t } = e, { selection: r } = t, { $from: n, empty: a } = r;
+        if (!a || n.parent.type !== this.type)
+          return !1;
+        const o = n.parentOffset === n.parent.nodeSize - 2, s = n.parent.textContent.endsWith(`
+
+`);
+        return !o || !s ? !1 : e.chain().command(({ tr: i }) => (i.delete(n.pos - 2, n.pos), !0)).exitCode().run();
+      },
+      // exit node on arrow down
+      ArrowDown: ({ editor: e }) => {
+        if (!this.options.exitOnArrowDown)
+          return !1;
+        const { state: t } = e, { selection: r, doc: n } = t, { $from: a, empty: o } = r;
+        if (!o || a.parent.type !== this.type || !(a.parentOffset === a.parent.nodeSize - 2))
+          return !1;
+        const i = a.after();
+        return i === void 0 ? !1 : n.nodeAt(i) ? e.commands.command(({ tr: c }) => (c.setSelection(L.near(n.resolve(i))), !0)) : e.commands.exitCode();
+      }
     };
+  },
+  addInputRules() {
+    return [
+      S({
+        find: M,
+        type: this.type,
+        getAttributes: (e) => ({
+          language: e[1]
+        })
+      }),
+      S({
+        find: N,
+        type: this.type,
+        getAttributes: (e) => ({
+          language: e[1]
+        })
+      })
+    ];
+  },
+  addProseMirrorPlugins() {
+    return [
+      // this plugin creates a code block for pasted content from VS Code
+      // we can also detect the copied code language
+      new w({
+        key: new B("codeBlockVSCodeHandler"),
+        props: {
+          handlePaste: (e, t) => {
+            if (!t.clipboardData || this.editor.isActive(this.type.name))
+              return !1;
+            const r = t.clipboardData.getData("text/plain"), n = t.clipboardData.getData("vscode-editor-data"), a = n ? JSON.parse(n) : void 0, o = a?.mode;
+            if (!r || !o)
+              return !1;
+            const { tr: s, schema: i } = e.state, l = i.text(r.replace(/\r\n?/g, `
+`));
+            return s.replaceSelectionWith(this.type.create({ language: o }, l)), s.selection.$from.parent.type !== this.type && s.setSelection(T.near(s.doc.resolve(Math.max(0, s.selection.from - 2)))), s.setMeta("paste", !0), e.dispatch(s), !0;
+          }
+        }
+      })
+    ];
   }
 });
 export {
-  p as Paragraph
+  $ as CodeBlock,
+  M as backtickInputRegex,
+  N as tildeInputRegex
 };

package/dist/index254.js

@@ -1,66 +1,12 @@
-import { Mark as r, markPasteRule as s, markInputRule as n, mergeAttributes as a } from "./index242.js";
-var i = /(?:^|\s)(~~(?!\s+~~)((?:[^~]+))~~(?!\s+~~))$/, d = /(?:^|\s)(~~(?!\s+~~)((?:[^~]+))~~(?!\s+~~))/g, o = r.create({
-  name: "strike",
-  addOptions() {
-    return {
-      HTMLAttributes: {}
-    };
-  },
-  parseHTML() {
-    return [
-      {
-        tag: "s"
-      },
-      {
-        tag: "del"
-      },
-      {
-        tag: "strike"
-      },
-      {
-        style: "text-decoration",
-        consuming: !1,
-        getAttrs: (e) => e.includes("line-through") ? {} : !1
-      }
-    ];
-  },
-  renderHTML({ HTMLAttributes: e }) {
-    return ["s", a(this.options.HTMLAttributes, e), 0];
-  },
-  markdownTokenName: "del",
-  parseMarkdown: (e, t) => t.applyMark("strike", t.parseInline(e.tokens || [])),
-  renderMarkdown: (e, t) => `~~${t.renderChildren(e)}~~`,
-  addCommands() {
-    return {
-      setStrike: () => ({ commands: e }) => e.setMark(this.name),
-      toggleStrike: () => ({ commands: e }) => e.toggleMark(this.name),
-      unsetStrike: () => ({ commands: e }) => e.unsetMark(this.name)
-    };
-  },
-  addKeyboardShortcuts() {
-    return {
-      "Mod-Shift-s": () => this.editor.commands.toggleStrike()
-    };
-  },
-  addInputRules() {
-    return [
-      n({
-        find: i,
-        type: this.type
-      })
-    ];
-  },
-  addPasteRules() {
-    return [
-      s({
-        find: d,
-        type: this.type
-      })
-    ];
-  }
+import { Node as n } from "./index249.js";
+var o = n.create({
+  name: "doc",
+  topNode: !0,
+  content: "block+",
+  renderMarkdown: (e, r) => e.content ? r.renderChildren(e.content, `
+
+`) : ""
 });
 export {
-  o as Strike,
-  i as inputRegex,
-  d as pasteRegex
+  o as Document
 };

package/dist/index255.js

@@ -1,13 +1,59 @@
-import { Node as t } from "./index242.js";
-var o = t.create({
-  name: "text",
+import { Node as l, mergeAttributes as c } from "./index249.js";
+var f = l.create({
+  name: "hardBreak",
+  markdownTokenName: "br",
+  addOptions() {
+    return {
+      keepMarks: !0,
+      HTMLAttributes: {}
+    };
+  },
+  inline: !0,
   group: "inline",
-  parseMarkdown: (e) => ({
-    type: "text",
-    text: e.text || ""
+  selectable: !1,
+  linebreakReplacement: !0,
+  parseHTML() {
+    return [{ tag: "br" }];
+  },
+  renderHTML({ HTMLAttributes: e }) {
+    return ["br", c(this.options.HTMLAttributes, e)];
+  },
+  renderText() {
+    return `
+`;
+  },
+  renderMarkdown: () => `  
+`,
+  parseMarkdown: () => ({
+    type: "hardBreak"
   }),
-  renderMarkdown: (e) => e.text || ""
+  addCommands() {
+    return {
+      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-Enter": () => this.editor.commands.setHardBreak(),
+      "Shift-Enter": () => this.editor.commands.setHardBreak()
+    };
+  }
 });
 export {
-  o as Text
+  f as HardBreak
 };