@quoreadmin/ui 1.9.3 → 1.10.1

package/dist/index210.js

@@ -1,118 +1,240 @@
-import { toArray as p, notNullish as x, noop as M, tryOnScopeDispose as g, watchImmediate as S, isClient as W, isObject as A } from "./index211.js";
-import { getLifeCycleTarget as q, tryOnUnmounted as z } from "./index211.js";
-import { toValue as a, computed as y, shallowRef as I, watch as T, unref as j, getCurrentInstance as w, onMounted as B } from "vue";
-const C = W ? window : void 0;
-function d(t) {
-  var o;
-  const l = a(t);
-  return (o = l?.$el) != null ? o : l;
-}
-function U(...t) {
-  const o = [], l = () => {
-    o.forEach((e) => e()), o.length = 0;
-  }, h = (e, n, u, r) => (e.addEventListener(n, u, r), () => e.removeEventListener(n, u, r)), c = y(() => {
-    const e = p(a(t[0])).filter((n) => n != null);
-    return e.every((n) => typeof n != "string") ? e : void 0;
-  }), m = S(
-    () => {
-      var e, n;
-      return [
-        (n = (e = c.value) == null ? void 0 : e.map((u) => d(u))) != null ? n : [C].filter((u) => u != null),
-        p(a(c.value ? t[1] : t[0])),
-        p(j(c.value ? t[2] : t[1])),
-        // @ts-expect-error - TypeScript gets the correct types, but somehow still complains
-        a(c.value ? t[3] : t[2])
-      ];
-    },
-    ([e, n, u, r]) => {
-      if (l(), !e?.length || !n?.length || !u?.length)
-        return;
-      const s = A(r) ? { ...r } : r;
-      o.push(
-        ...e.flatMap(
-          (b) => n.flatMap(
-            (v) => u.map((i) => h(b, v, i, s))
-          )
-        )
-      );
-    },
-    { flush: "post" }
-  ), f = () => {
-    m(), l();
-  };
-  return g(l), f;
-}
-// @__NO_SIDE_EFFECTS__
-function D() {
-  const t = I(!1), o = w();
-  return o && B(() => {
-    t.value = !0;
-  }, o), t;
-}
-// @__NO_SIDE_EFFECTS__
-function N(t) {
-  const o = /* @__PURE__ */ D();
-  return y(() => (o.value, !!t()));
-}
-function V(t, o, l = {}) {
-  const {
-    root: h,
-    rootMargin: c = "0px",
-    threshold: m = 0,
-    window: f = C,
-    immediate: e = !0
-  } = l, n = /* @__PURE__ */ N(() => f && "IntersectionObserver" in f), u = y(() => {
-    const i = a(t);
-    return p(i).map(d).filter(x);
+import { Mark as y, mergeAttributes as p, Extension as l } from "./index267.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}`);
   });
-  let r = M;
-  const s = I(e), b = n.value ? T(
-    () => [u.value, d(h), s.value],
-    ([i, L]) => {
-      if (r(), !s.value || !i.length)
-        return;
-      const E = new IntersectionObserver(
-        o,
-        {
-          root: d(L),
-          rootMargin: c,
-          threshold: m
+}, 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}`
+            } : {}
+          }
         }
-      );
-      i.forEach((O) => O && E.observe(O)), r = () => {
-        E.disconnect(), r = M;
-      };
-    },
-    { immediate: e, flush: "post" }
-  ) : M, v = () => {
-    r(), b(), s.value = !1;
-  };
-  return g(v), {
-    isSupported: n,
-    isActive: s,
-    pause() {
-      r(), s.value = !1;
-    },
-    resume() {
-      s.value = !0;
-    },
-    stop: v
-  };
-}
+      }
+    ];
+  },
+  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 defaultWindow,
-  q as getLifeCycleTarget,
-  W as isClient,
-  A as isObject,
-  M as noop,
-  x as notNullish,
-  p as toArray,
-  g as tryOnScopeDispose,
-  z as tryOnUnmounted,
-  d as unrefElement,
-  U as useEventListener,
-  V as useIntersectionObserver,
-  D as useMounted,
-  N as useSupported,
-  S as watchImmediate
+  m as BackgroundColor,
+  g as Color,
+  h as FontFamily,
+  S as FontSize,
+  b as LineHeight,
+  c as TextStyle
 };

package/dist/index211.js

@@ -1,38 +1,313 @@
-import { onUnmounted as o, getCurrentInstance as r, getCurrentScope as c, onScopeDispose as i, watch as s } from "vue";
-function p(t) {
-  return c() ? (i(t), !0) : !1;
+import { Mark as x, markPasteRule as b, mergeAttributes as v, combineTransactionSteps as w, getChangedRanges as T, findChildrenInRange as _, getMarksBetween as O, getAttributes as R } from "./index267.js";
+import { registerCustomProtocol as C, tokenize as H, find as M, reset as U } from "./index281.js";
+import { Plugin as g, PluginKey as A } from "./index282.js";
+var P = "[\0-   ᠎ -\u2029 　]", B = new RegExp(P), I = new RegExp(`${P}$`), W = new RegExp(P, "g");
+function $(t) {
+  return t.length === 1 ? t[0].isLink : t.length === 3 && t[1].isLink ? ["()", "[]"].includes(t[0].value + t[2].value) : !1;
 }
-const l = typeof window < "u" && typeof document < "u";
-typeof WorkerGlobalScope < "u" && globalThis instanceof WorkerGlobalScope;
-const d = (t) => t != null, u = Object.prototype.toString, y = (t) => u.call(t) === "[object Object]", m = () => {
-};
-function g(t) {
-  return Array.isArray(t) ? t : [t];
-}
-function f(t) {
-  return r();
+function z(t) {
+  return new g({
+    key: new A("autolink"),
+    appendTransaction: (e, r, o) => {
+      const n = e.some((a) => a.docChanged) && !r.doc.eq(o.doc), l = e.some((a) => a.getMeta("preventAutolink"));
+      if (!n || l)
+        return;
+      const { tr: i } = o, d = w(r.doc, [...e]);
+      if (T(d).forEach(({ newRange: a }) => {
+        const f = _(o.doc, a, (h) => h.isTextblock);
+        let c, k;
+        if (f.length > 1)
+          c = f[0], k = o.doc.textBetween(
+            c.pos,
+            c.pos + c.node.nodeSize,
+            void 0,
+            " "
+          );
+        else if (f.length) {
+          const h = o.doc.textBetween(a.from, a.to, " ", " ");
+          if (!I.test(h))
+            return;
+          c = f[0], k = o.doc.textBetween(c.pos, a.to, void 0, " ");
+        }
+        if (c && k) {
+          const h = k.split(B).filter(Boolean);
+          if (h.length <= 0)
+            return !1;
+          const m = h[h.length - 1], E = c.pos + k.lastIndexOf(m);
+          if (!m)
+            return !1;
+          const L = H(m).map((s) => s.toObject(t.defaultProtocol));
+          if (!$(L))
+            return !1;
+          L.filter((s) => s.isLink).map((s) => ({
+            ...s,
+            from: E + s.start + 1,
+            to: E + s.end + 1
+          })).filter((s) => o.schema.marks.code ? !o.doc.rangeHasMark(s.from, s.to, o.schema.marks.code) : !0).filter((s) => t.validate(s.value)).filter((s) => t.shouldAutoLink(s.value)).forEach((s) => {
+            O(s.from, s.to, o.doc).some((y) => y.mark.type === t.type) || i.addMark(
+              s.from,
+              s.to,
+              t.type.create({
+                href: s.href
+              })
+            );
+          });
+        }
+      }), !!i.steps.length)
+        return i;
+    }
+  });
 }
-function b(t, n) {
-  f() && o(t, n);
+function N(t) {
+  return new g({
+    key: new A("handleClickLink"),
+    props: {
+      handleClick: (e, r, o) => {
+        var n, l;
+        if (o.button !== 0 || !e.editable)
+          return !1;
+        let i = null;
+        if (o.target instanceof HTMLAnchorElement)
+          i = o.target;
+        else {
+          const u = o.target;
+          if (!u)
+            return !1;
+          const a = t.editor.view.dom;
+          i = u.closest("a"), i && !a.contains(i) && (i = null);
+        }
+        if (!i)
+          return !1;
+        let d = !1;
+        if (t.enableClickSelection && (d = t.editor.commands.extendMarkRange(t.type.name)), t.openOnClick) {
+          const u = R(e.state, t.type.name), a = (n = i.href) != null ? n : u.href, f = (l = i.target) != null ? l : u.target;
+          a && (window.open(a, f), d = !0);
+        }
+        return d;
+      }
+    }
+  });
 }
-function S(t, n, e) {
-  return s(
-    t,
-    n,
-    {
-      ...e,
-      immediate: !0
+function V(t) {
+  return new g({
+    key: new A("handlePasteLink"),
+    props: {
+      handlePaste: (e, r, o) => {
+        const { shouldAutoLink: n } = t, { state: l } = e, { selection: i } = l, { empty: d } = i;
+        if (d)
+          return !1;
+        let u = "";
+        o.content.forEach((f) => {
+          u += f.textContent;
+        });
+        const a = M(u, { defaultProtocol: t.defaultProtocol }).find(
+          (f) => f.isLink && f.value === u
+        );
+        return !u || !a || n !== void 0 && !n(a.value) ? !1 : t.editor.commands.setMark(t.type, {
+          href: a.href
+        });
+      }
     }
+  });
+}
+function p(t, e) {
+  const r = ["http", "https", "ftp", "ftps", "mailto", "tel", "callto", "sms", "cid", "xmpp"];
+  return e && e.forEach((o) => {
+    const n = typeof o == "string" ? o : o.scheme;
+    n && r.push(n);
+  }), !t || t.replace(W, "").match(
+    new RegExp(
+      // eslint-disable-next-line no-useless-escape
+      `^(?:(?:${r.join("|")}):|[^a-z]|[a-z0-9+.-]+(?:[^a-z+.-:]|$))`,
+      "i"
+    )
   );
 }
+var X = x.create({
+  name: "link",
+  priority: 1e3,
+  keepOnSplit: !1,
+  exitable: !0,
+  onCreate() {
+    this.options.validate && !this.options.shouldAutoLink && (this.options.shouldAutoLink = this.options.validate, console.warn("The `validate` option is deprecated. Rename to the `shouldAutoLink` option instead.")), this.options.protocols.forEach((t) => {
+      if (typeof t == "string") {
+        C(t);
+        return;
+      }
+      C(t.scheme, t.optionalSlashes);
+    });
+  },
+  onDestroy() {
+    U();
+  },
+  inclusive() {
+    return this.options.autolink;
+  },
+  addOptions() {
+    return {
+      openOnClick: !0,
+      enableClickSelection: !1,
+      linkOnPaste: !0,
+      autolink: !0,
+      protocols: [],
+      defaultProtocol: "http",
+      HTMLAttributes: {
+        target: "_blank",
+        rel: "noopener noreferrer nofollow",
+        class: null
+      },
+      isAllowedUri: (t, e) => !!p(t, e.protocols),
+      validate: (t) => !!t,
+      shouldAutoLink: (t) => {
+        const e = /^[a-z][a-z0-9+.-]*:\/\//i.test(t), r = /^[a-z][a-z0-9+.-]*:/i.test(t);
+        if (e || r && !t.includes("@"))
+          return !0;
+        const n = (t.includes("@") ? t.split("@").pop() : t).split(/[/?#:]/)[0];
+        return !(/^\d{1,3}(\.\d{1,3}){3}$/.test(n) || !/\./.test(n));
+      }
+    };
+  },
+  addAttributes() {
+    return {
+      href: {
+        default: null,
+        parseHTML(t) {
+          return t.getAttribute("href");
+        }
+      },
+      target: {
+        default: this.options.HTMLAttributes.target
+      },
+      rel: {
+        default: this.options.HTMLAttributes.rel
+      },
+      class: {
+        default: this.options.HTMLAttributes.class
+      },
+      title: {
+        default: null
+      }
+    };
+  },
+  parseHTML() {
+    return [
+      {
+        tag: "a[href]",
+        getAttrs: (t) => {
+          const e = t.getAttribute("href");
+          return !e || !this.options.isAllowedUri(e, {
+            defaultValidate: (r) => !!p(r, this.options.protocols),
+            protocols: this.options.protocols,
+            defaultProtocol: this.options.defaultProtocol
+          }) ? !1 : null;
+        }
+      }
+    ];
+  },
+  renderHTML({ HTMLAttributes: t }) {
+    return this.options.isAllowedUri(t.href, {
+      defaultValidate: (e) => !!p(e, this.options.protocols),
+      protocols: this.options.protocols,
+      defaultProtocol: this.options.defaultProtocol
+    }) ? ["a", v(this.options.HTMLAttributes, t), 0] : ["a", v(this.options.HTMLAttributes, { ...t, href: "" }), 0];
+  },
+  markdownTokenName: "link",
+  parseMarkdown: (t, e) => e.applyMark("link", e.parseInline(t.tokens || []), {
+    href: t.href,
+    title: t.title || null
+  }),
+  renderMarkdown: (t, e) => {
+    var r, o, n, l;
+    const i = (o = (r = t.attrs) == null ? void 0 : r.href) != null ? o : "", d = (l = (n = t.attrs) == null ? void 0 : n.title) != null ? l : "", u = e.renderChildren(t);
+    return d ? `[${u}](${i} "${d}")` : `[${u}](${i})`;
+  },
+  addCommands() {
+    return {
+      setLink: (t) => ({ chain: e }) => {
+        const { href: r } = t;
+        return this.options.isAllowedUri(r, {
+          defaultValidate: (o) => !!p(o, this.options.protocols),
+          protocols: this.options.protocols,
+          defaultProtocol: this.options.defaultProtocol
+        }) ? e().setMark(this.name, t).setMeta("preventAutolink", !0).run() : !1;
+      },
+      toggleLink: (t) => ({ chain: e }) => {
+        const { href: r } = t || {};
+        return r && !this.options.isAllowedUri(r, {
+          defaultValidate: (o) => !!p(o, this.options.protocols),
+          protocols: this.options.protocols,
+          defaultProtocol: this.options.defaultProtocol
+        }) ? !1 : e().toggleMark(this.name, t, { extendEmptyMarkRange: !0 }).setMeta("preventAutolink", !0).run();
+      },
+      unsetLink: () => ({ chain: t }) => t().unsetMark(this.name, { extendEmptyMarkRange: !0 }).setMeta("preventAutolink", !0).run()
+    };
+  },
+  addPasteRules() {
+    return [
+      b({
+        find: (t) => {
+          const e = [];
+          if (t) {
+            const { protocols: r, defaultProtocol: o } = this.options, n = M(t).filter(
+              (l) => l.isLink && this.options.isAllowedUri(l.value, {
+                defaultValidate: (i) => !!p(i, r),
+                protocols: r,
+                defaultProtocol: o
+              })
+            );
+            n.length && n.forEach((l) => {
+              this.options.shouldAutoLink(l.value) && e.push({
+                text: l.value,
+                data: {
+                  href: l.href
+                },
+                index: l.start
+              });
+            });
+          }
+          return e;
+        },
+        type: this.type,
+        getAttributes: (t) => {
+          var e;
+          return {
+            href: (e = t.data) == null ? void 0 : e.href
+          };
+        }
+      })
+    ];
+  },
+  addProseMirrorPlugins() {
+    const t = [], { protocols: e, defaultProtocol: r } = this.options;
+    return this.options.autolink && t.push(
+      z({
+        type: this.type,
+        defaultProtocol: this.options.defaultProtocol,
+        validate: (o) => this.options.isAllowedUri(o, {
+          defaultValidate: (n) => !!p(n, e),
+          protocols: e,
+          defaultProtocol: r
+        }),
+        shouldAutoLink: this.options.shouldAutoLink
+      })
+    ), t.push(
+      N({
+        type: this.type,
+        editor: this.editor,
+        openOnClick: this.options.openOnClick === "whenNotEditable" ? !0 : this.options.openOnClick,
+        enableClickSelection: this.options.enableClickSelection
+      })
+    ), this.options.linkOnPaste && t.push(
+      V({
+        editor: this.editor,
+        defaultProtocol: this.options.defaultProtocol,
+        type: this.type,
+        shouldAutoLink: this.options.shouldAutoLink
+      })
+    ), t;
+  }
+});
 export {
-  f as getLifeCycleTarget,
-  l as isClient,
-  y as isObject,
-  m as noop,
-  d as notNullish,
-  g as toArray,
-  p as tryOnScopeDispose,
-  b as tryOnUnmounted,
-  S as watchImmediate
+  X as Link,
+  p as isAllowedUri
 };