@vc-shell/framework 2.0.0-alpha.3 → 2.0.0-alpha.31

package/dist/chunks/vendor-tiptap-extension-text-style-BDbT1PMb.js

@@ -0,0 +1,235 @@
+import { M as y, m as p, k as l } from "./vendor-tiptap-core-BWgKs47g.js";
+var d = 20, u = (t, e = 0) => {
+  const r = [];
+  return !t.children.length || e > d || Array.from(t.children).forEach((o) => {
+    o.tagName === "SPAN" ? r.push(o) : o.children.length && r.push(...u(o, e + 1));
+  }), r;
+}, f = (t) => {
+  if (!t.children.length)
+    return;
+  const e = u(t);
+  e && e.forEach((r) => {
+    var o, n;
+    const s = r.getAttribute("style"), i = (n = (o = r.parentElement) == null ? void 0 : o.closest("span")) == null ? void 0 : n.getAttribute("style");
+    r.setAttribute("style", `${i};${s}`);
+  });
+}, c = y.create({
+  name: "textStyle",
+  priority: 101,
+  addOptions() {
+    return {
+      HTMLAttributes: {},
+      mergeNestedSpanStyles: !0
+    };
+  },
+  parseHTML() {
+    return [
+      {
+        tag: "span",
+        consuming: !1,
+        getAttrs: (t) => t.hasAttribute("style") ? (this.options.mergeNestedSpanStyles && f(t), {}) : !1
+      }
+    ];
+  },
+  renderHTML({ HTMLAttributes: t }) {
+    return ["span", p(this.options.HTMLAttributes, t), 0];
+  },
+  addCommands() {
+    return {
+      toggleTextStyle: (t) => ({ commands: e }) => e.toggleMark(this.name, t),
+      removeEmptyTextStyle: () => ({ tr: t }) => {
+        const { selection: e } = t;
+        return t.doc.nodesBetween(e.from, e.to, (r, o) => {
+          if (r.isTextblock)
+            return !0;
+          r.marks.filter((n) => n.type === this.type).some((n) => Object.values(n.attrs).some((s) => !!s)) || t.removeMark(o, o + r.nodeSize, this.type);
+        }), !0;
+      }
+    };
+  }
+}), m = l.create({
+  name: "backgroundColor",
+  addOptions() {
+    return {
+      types: ["textStyle"]
+    };
+  },
+  addGlobalAttributes() {
+    return [
+      {
+        types: this.options.types,
+        attributes: {
+          backgroundColor: {
+            default: null,
+            parseHTML: (t) => {
+              var e;
+              const r = t.getAttribute("style");
+              if (r) {
+                const o = r.split(";").map((n) => n.trim()).filter(Boolean);
+                for (let n = o.length - 1; n >= 0; n -= 1) {
+                  const s = o[n].split(":");
+                  if (s.length >= 2) {
+                    const i = s[0].trim().toLowerCase(), a = s.slice(1).join(":").trim();
+                    if (i === "background-color")
+                      return a.replace(/['"]+/g, "");
+                  }
+                }
+              }
+              return (e = t.style.backgroundColor) == null ? void 0 : e.replace(/['"]+/g, "");
+            },
+            renderHTML: (t) => t.backgroundColor ? {
+              style: `background-color: ${t.backgroundColor}`
+            } : {}
+          }
+        }
+      }
+    ];
+  },
+  addCommands() {
+    return {
+      setBackgroundColor: (t) => ({ chain: e }) => e().setMark("textStyle", { backgroundColor: t }).run(),
+      unsetBackgroundColor: () => ({ chain: t }) => t().setMark("textStyle", { backgroundColor: null }).removeEmptyTextStyle().run()
+    };
+  }
+}), g = l.create({
+  name: "color",
+  addOptions() {
+    return {
+      types: ["textStyle"]
+    };
+  },
+  addGlobalAttributes() {
+    return [
+      {
+        types: this.options.types,
+        attributes: {
+          color: {
+            default: null,
+            parseHTML: (t) => {
+              var e;
+              const r = t.getAttribute("style");
+              if (r) {
+                const o = r.split(";").map((n) => n.trim()).filter(Boolean);
+                for (let n = o.length - 1; n >= 0; n -= 1) {
+                  const s = o[n].split(":");
+                  if (s.length >= 2) {
+                    const i = s[0].trim().toLowerCase(), a = s.slice(1).join(":").trim();
+                    if (i === "color")
+                      return a.replace(/['"]+/g, "");
+                  }
+                }
+              }
+              return (e = t.style.color) == null ? void 0 : e.replace(/['"]+/g, "");
+            },
+            renderHTML: (t) => t.color ? {
+              style: `color: ${t.color}`
+            } : {}
+          }
+        }
+      }
+    ];
+  },
+  addCommands() {
+    return {
+      setColor: (t) => ({ chain: e }) => e().setMark("textStyle", { color: t }).run(),
+      unsetColor: () => ({ chain: t }) => t().setMark("textStyle", { color: null }).removeEmptyTextStyle().run()
+    };
+  }
+}), h = l.create({
+  name: "fontFamily",
+  addOptions() {
+    return {
+      types: ["textStyle"]
+    };
+  },
+  addGlobalAttributes() {
+    return [
+      {
+        types: this.options.types,
+        attributes: {
+          fontFamily: {
+            default: null,
+            parseHTML: (t) => t.style.fontFamily,
+            renderHTML: (t) => t.fontFamily ? {
+              style: `font-family: ${t.fontFamily}`
+            } : {}
+          }
+        }
+      }
+    ];
+  },
+  addCommands() {
+    return {
+      setFontFamily: (t) => ({ chain: e }) => e().setMark("textStyle", { fontFamily: t }).run(),
+      unsetFontFamily: () => ({ chain: t }) => t().setMark("textStyle", { fontFamily: null }).removeEmptyTextStyle().run()
+    };
+  }
+}), S = l.create({
+  name: "fontSize",
+  addOptions() {
+    return {
+      types: ["textStyle"]
+    };
+  },
+  addGlobalAttributes() {
+    return [
+      {
+        types: this.options.types,
+        attributes: {
+          fontSize: {
+            default: null,
+            parseHTML: (t) => t.style.fontSize,
+            renderHTML: (t) => t.fontSize ? {
+              style: `font-size: ${t.fontSize}`
+            } : {}
+          }
+        }
+      }
+    ];
+  },
+  addCommands() {
+    return {
+      setFontSize: (t) => ({ chain: e }) => e().setMark("textStyle", { fontSize: t }).run(),
+      unsetFontSize: () => ({ chain: t }) => t().setMark("textStyle", { fontSize: null }).removeEmptyTextStyle().run()
+    };
+  }
+}), b = l.create({
+  name: "lineHeight",
+  addOptions() {
+    return {
+      types: ["textStyle"]
+    };
+  },
+  addGlobalAttributes() {
+    return [
+      {
+        types: this.options.types,
+        attributes: {
+          lineHeight: {
+            default: null,
+            parseHTML: (t) => t.style.lineHeight,
+            renderHTML: (t) => t.lineHeight ? {
+              style: `line-height: ${t.lineHeight}`
+            } : {}
+          }
+        }
+      }
+    ];
+  },
+  addCommands() {
+    return {
+      setLineHeight: (t) => ({ chain: e }) => e().setMark("textStyle", { lineHeight: t }).run(),
+      unsetLineHeight: () => ({ chain: t }) => t().setMark("textStyle", { lineHeight: null }).removeEmptyTextStyle().run()
+    };
+  }
+});
+l.create({
+  name: "textStyleKit",
+  addExtensions() {
+    const t = [];
+    return this.options.backgroundColor !== !1 && t.push(m.configure(this.options.backgroundColor)), this.options.color !== !1 && t.push(g.configure(this.options.color)), this.options.fontFamily !== !1 && t.push(h.configure(this.options.fontFamily)), this.options.fontSize !== !1 && t.push(S.configure(this.options.fontSize)), this.options.lineHeight !== !1 && t.push(b.configure(this.options.lineHeight)), this.options.textStyle !== !1 && t.push(c.configure(this.options.textStyle)), t;
+  }
+});
+export {
+  c as T
+};

package/dist/chunks/vendor-tiptap-extension-underline-CiUEdG6D.js

@@ -0,0 +1,65 @@
+import { M as s, m as a } from "./vendor-tiptap-core-BWgKs47g.js";
+var u = s.create({
+  name: "underline",
+  addOptions() {
+    return {
+      HTMLAttributes: {}
+    };
+  },
+  parseHTML() {
+    return [
+      {
+        tag: "u"
+      },
+      {
+        style: "text-decoration",
+        consuming: !1,
+        getAttrs: (e) => e.includes("underline") ? {} : !1
+      }
+    ];
+  },
+  renderHTML({ HTMLAttributes: e }) {
+    return ["u", a(this.options.HTMLAttributes, e), 0];
+  },
+  parseMarkdown(e, n) {
+    return n.applyMark(this.name || "underline", n.parseInline(e.tokens || []));
+  },
+  renderMarkdown(e, n) {
+    return `++${n.renderChildren(e)}++`;
+  },
+  markdownTokenizer: {
+    name: "underline",
+    level: "inline",
+    start(e) {
+      return e.indexOf("++");
+    },
+    tokenize(e, n, i) {
+      const r = /^(\+\+)([\s\S]+?)(\+\+)/.exec(e);
+      if (!r)
+        return;
+      const t = r[2].trim();
+      return {
+        type: "underline",
+        raw: r[0],
+        text: t,
+        tokens: i.inlineTokens(t)
+      };
+    }
+  },
+  addCommands() {
+    return {
+      setUnderline: () => ({ commands: e }) => e.setMark(this.name),
+      toggleUnderline: () => ({ commands: e }) => e.toggleMark(this.name),
+      unsetUnderline: () => ({ commands: e }) => e.unsetMark(this.name)
+    };
+  },
+  addKeyboardShortcuts() {
+    return {
+      "Mod-u": () => this.editor.commands.toggleUnderline(),
+      "Mod-U": () => this.editor.commands.toggleUnderline()
+    };
+  }
+});
+export {
+  u as U
+};

package/dist/chunks/vendor-tiptap-extensions-pwHVUzkb.js

@@ -0,0 +1,299 @@
+import { k as l, x as P, y as S, z, i as N } from "./vendor-tiptap-core-BWgKs47g.js";
+import { P as p, a as m } from "./vendor-prosemirror-state-IeimrELV.js";
+import { d as T } from "./vendor-prosemirror-dropcursor-kF5UKNFM.js";
+import { D as f, a as y } from "./vendor-prosemirror-view-Chu67Jpw.js";
+import { g as E } from "./vendor-prosemirror-gapcursor-D3tpkzBp.js";
+import { h as M, r as x, u as A } from "./vendor-prosemirror-history-CQYKHz3u.js";
+l.create({
+  name: "characterCount",
+  addOptions() {
+    return {
+      limit: null,
+      mode: "textSize",
+      textCounter: (e) => e.length,
+      wordCounter: (e) => e.split(" ").filter((t) => t !== "").length
+    };
+  },
+  addStorage() {
+    return {
+      characters: () => 0,
+      words: () => 0
+    };
+  },
+  onBeforeCreate() {
+    this.storage.characters = (e) => {
+      const t = e?.node || this.editor.state.doc;
+      if ((e?.mode || this.options.mode) === "textSize") {
+        const o = t.textBetween(0, t.content.size, void 0, " ");
+        return this.options.textCounter(o);
+      }
+      return t.nodeSize;
+    }, this.storage.words = (e) => {
+      const t = e?.node || this.editor.state.doc, s = t.textBetween(0, t.content.size, " ", " ");
+      return this.options.wordCounter(s);
+    };
+  },
+  addProseMirrorPlugins() {
+    let e = !1;
+    return [
+      new p({
+        key: new m("characterCount"),
+        appendTransaction: (t, s, o) => {
+          if (e)
+            return;
+          const r = this.options.limit;
+          if (r == null || r === 0) {
+            e = !0;
+            return;
+          }
+          const n = this.storage.characters({ node: o.doc });
+          if (n > r) {
+            const c = n - r, a = 0, i = c;
+            console.warn(
+              `[CharacterCount] Initial content exceeded limit of ${r} characters. Content was automatically trimmed.`
+            );
+            const d = o.tr.deleteRange(a, i);
+            return e = !0, d;
+          }
+          e = !0;
+        },
+        filterTransaction: (t, s) => {
+          const o = this.options.limit;
+          if (!t.docChanged || o === 0 || o === null || o === void 0)
+            return !0;
+          const r = this.storage.characters({ node: s.doc }), n = this.storage.characters({ node: t.doc });
+          if (n <= o || r > o && n > o && n <= r)
+            return !0;
+          if (r > o && n > o && n > r || !t.getMeta("paste"))
+            return !1;
+          const a = t.selection.$head.pos, i = n - o, d = a - i, u = a;
+          return t.deleteRange(d, u), !(this.storage.characters({ node: t.doc }) > o);
+        }
+      })
+    ];
+  }
+});
+var L = l.create({
+  name: "dropCursor",
+  addOptions() {
+    return {
+      color: "currentColor",
+      width: 1,
+      class: void 0
+    };
+  },
+  addProseMirrorPlugins() {
+    return [T(this.options)];
+  }
+});
+l.create({
+  name: "focus",
+  addOptions() {
+    return {
+      className: "has-focus",
+      mode: "all"
+    };
+  },
+  addProseMirrorPlugins() {
+    return [
+      new p({
+        key: new m("focus"),
+        props: {
+          decorations: ({ doc: e, selection: t }) => {
+            const { isEditable: s, isFocused: o } = this.editor, { anchor: r } = t, n = [];
+            if (!s || !o)
+              return f.create(e, []);
+            let c = 0;
+            this.options.mode === "deepest" && e.descendants((i, d) => {
+              if (i.isText)
+                return;
+              if (!(r >= d && r <= d + i.nodeSize - 1))
+                return !1;
+              c += 1;
+            });
+            let a = 0;
+            return e.descendants((i, d) => {
+              if (i.isText || !(r >= d && r <= d + i.nodeSize - 1))
+                return !1;
+              if (a += 1, this.options.mode === "deepest" && c - a > 0 || this.options.mode === "shallowest" && a > 1)
+                return this.options.mode === "deepest";
+              n.push(
+                y.node(d, d + i.nodeSize, {
+                  class: this.options.className
+                })
+              );
+            }), f.create(e, n);
+          }
+        }
+      })
+    ];
+  }
+});
+var B = l.create({
+  name: "gapCursor",
+  addProseMirrorPlugins() {
+    return [E()];
+  },
+  extendNodeSchema(e) {
+    var t;
+    const s = {
+      name: e.name,
+      options: e.options,
+      storage: e.storage
+    };
+    return {
+      allowGapCursor: (t = P(S(e, "allowGapCursor", s))) != null ? t : null
+    };
+  }
+}), C = "placeholder";
+function O(e) {
+  return e.replace(/\s+/g, "-").replace(/[^a-zA-Z0-9-]/g, "").replace(/^[0-9-]+/, "").replace(/^-+/, "").toLowerCase();
+}
+var I = l.create({
+  name: "placeholder",
+  addOptions() {
+    return {
+      emptyEditorClass: "is-editor-empty",
+      emptyNodeClass: "is-empty",
+      dataAttribute: C,
+      placeholder: "Write something …",
+      showOnlyWhenEditable: !0,
+      showOnlyCurrent: !0,
+      includeChildren: !1
+    };
+  },
+  addProseMirrorPlugins() {
+    const e = this.options.dataAttribute ? `data-${O(this.options.dataAttribute)}` : `data-${C}`;
+    return [
+      new p({
+        key: new m("placeholder"),
+        props: {
+          decorations: ({ doc: t, selection: s }) => {
+            const o = this.editor.isEditable || !this.options.showOnlyWhenEditable, { anchor: r } = s, n = [];
+            if (!o)
+              return null;
+            const c = this.editor.isEmpty;
+            return t.descendants((a, i) => {
+              const d = r >= i && r <= i + a.nodeSize, u = !a.isLeaf && z(a);
+              if (!a.type.isTextblock)
+                return this.options.includeChildren;
+              if ((d || !this.options.showOnlyCurrent) && u) {
+                const h = [this.options.emptyNodeClass];
+                c && h.push(this.options.emptyEditorClass);
+                const g = y.node(i, i + a.nodeSize, {
+                  class: h.join(" "),
+                  [e]: typeof this.options.placeholder == "function" ? this.options.placeholder({
+                    editor: this.editor,
+                    node: a,
+                    pos: i,
+                    hasAnchor: d
+                  }) : this.options.placeholder
+                });
+                n.push(g);
+              }
+              return this.options.includeChildren;
+            }), f.create(t, n);
+          }
+        }
+      })
+    ];
+  }
+});
+l.create({
+  name: "selection",
+  addOptions() {
+    return {
+      className: "selection"
+    };
+  },
+  addProseMirrorPlugins() {
+    const { editor: e, options: t } = this;
+    return [
+      new p({
+        key: new m("selection"),
+        props: {
+          decorations(s) {
+            return s.selection.empty || e.isFocused || !e.isEditable || N(s.selection) || e.view.dragging ? null : f.create(s.doc, [
+              y.inline(s.selection.from, s.selection.to, {
+                class: t.className
+              })
+            ]);
+          }
+        }
+      })
+    ];
+  }
+});
+var b = "skipTrailingNode";
+function w({ types: e, node: t }) {
+  return t && Array.isArray(e) && e.includes(t.type) || t?.type === e;
+}
+var U = l.create({
+  name: "trailingNode",
+  addOptions() {
+    return {
+      node: void 0,
+      notAfter: []
+    };
+  },
+  addProseMirrorPlugins() {
+    var e;
+    const t = new m(this.name), s = this.options.node || ((e = this.editor.schema.topNodeType.contentMatch.defaultType) == null ? void 0 : e.name) || "paragraph", o = Object.entries(this.editor.schema.nodes).map(([, r]) => r).filter((r) => (this.options.notAfter || []).concat(s).includes(r.name));
+    return [
+      new p({
+        key: t,
+        appendTransaction: (r, n, c) => {
+          const { doc: a, tr: i, schema: d } = c, u = t.getState(c), h = a.content.size, g = d.nodes[s];
+          if (!r.some((v) => v.getMeta(b)) && u)
+            return i.insert(h, g.create());
+        },
+        state: {
+          init: (r, n) => {
+            const c = n.tr.doc.lastChild;
+            return !w({ node: c, types: o });
+          },
+          apply: (r, n) => {
+            if (!r.docChanged || r.getMeta("__uniqueIDTransaction"))
+              return n;
+            const c = r.doc.lastChild;
+            return !w({ node: c, types: o });
+          }
+        }
+      })
+    ];
+  }
+}), $ = l.create({
+  name: "undoRedo",
+  addOptions() {
+    return {
+      depth: 100,
+      newGroupDelay: 500
+    };
+  },
+  addCommands() {
+    return {
+      undo: () => ({ state: e, dispatch: t }) => A(e, t),
+      redo: () => ({ state: e, dispatch: t }) => x(e, t)
+    };
+  },
+  addProseMirrorPlugins() {
+    return [M(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-я": () => this.editor.commands.undo(),
+      "Shift-Mod-я": () => this.editor.commands.redo()
+    };
+  }
+});
+export {
+  L as D,
+  B as G,
+  I as P,
+  U as T,
+  $ as U
+};