@opengis/form 0.1.39 → 0.1.40

package/dist/index-CkUvn8lm.js

@@ -0,0 +1,153 @@
+import { N as M, n as R, m as v, R as x, c as $ } from "./index-pYkcVgEL.js";
+var z = /(?:^|\s)(!\[(.+|:?)]\((\S+)(?:(?:\s+)["'](\S+)["'])?\))$/, _ = M.create({
+  name: "image",
+  addOptions() {
+    return {
+      inline: !1,
+      allowBase64: !1,
+      HTMLAttributes: {},
+      resize: !1
+    };
+  },
+  inline() {
+    return this.options.inline;
+  },
+  group() {
+    return this.options.inline ? "inline" : "block";
+  },
+  draggable: !0,
+  addAttributes() {
+    return {
+      src: {
+        default: null
+      },
+      alt: {
+        default: null
+      },
+      title: {
+        default: null
+      },
+      width: {
+        default: null
+      },
+      height: {
+        default: null
+      }
+    };
+  },
+  parseHTML() {
+    return [
+      {
+        tag: this.options.allowBase64 ? "img[src]" : 'img[src]:not([src^="data:"])'
+      }
+    ];
+  },
+  renderHTML({ HTMLAttributes: e }) {
+    return ["img", v(this.options.HTMLAttributes, e)];
+  },
+  parseMarkdown: (e, i) => i.createNode("image", {
+    src: e.href,
+    title: e.title,
+    alt: e.text
+  }),
+  renderMarkdown: (e) => {
+    var i, l, o, c, d, h;
+    const u = (l = (i = e.attrs) == null ? void 0 : i.src) != null ? l : "", f = (c = (o = e.attrs) == null ? void 0 : o.alt) != null ? c : "", t = (h = (d = e.attrs) == null ? void 0 : d.title) != null ? h : "";
+    return t ? `![${f}](${u} "${t}")` : `![${f}](${u})`;
+  },
+  addNodeView() {
+    if (!this.options.resize || !this.options.resize.enabled || typeof document > "u")
+      return null;
+    const { directions: e, minWidth: i, minHeight: l, alwaysPreserveAspectRatio: o } = this.options.resize, c = /* @__PURE__ */ new Set(["src", "width", "height"]);
+    return ({ node: d, getPos: h, HTMLAttributes: u, editor: f }) => {
+      const t = document.createElement("img");
+      t.draggable = !1;
+      const m = v(this.options.HTMLAttributes, u);
+      Object.entries(m).forEach(([r, n]) => {
+        if (n != null)
+          switch (r) {
+            case "src":
+            case "width":
+            case "height":
+              break;
+            default:
+              t.setAttribute(r, n);
+              break;
+          }
+      }), m.src !== null && (t.src = m.src);
+      let b = { ...u };
+      const g = (r) => {
+        if (typeof r == "string" && r !== "") {
+          t.getAttribute("src") !== r && (t.src = r);
+          return;
+        }
+        t.hasAttribute("src") && t.removeAttribute("src"), t.src !== "" && (t.src = "");
+      };
+      g(u.src);
+      const y = (r) => {
+        if (r.type !== d.type)
+          return !1;
+        const n = f.extensionManager.attributes.filter(
+          (s) => s.type === r.type.name
+        ), a = $(r, n);
+        return Object.keys(b).forEach((s) => {
+          !c.has(s) && !(s in a) && t.removeAttribute(s);
+        }), Object.entries(a).forEach(([s, w]) => {
+          c.has(s) || (w != null ? t.setAttribute(s, w) : t.removeAttribute(s));
+        }), g(a.src), b = a, !0;
+      }, A = new x({
+        element: t,
+        editor: f,
+        node: d,
+        getPos: h,
+        onResize: (r, n) => {
+          t.style.width = `${r}px`, t.style.height = `${n}px`;
+        },
+        onCommit: (r, n) => {
+          const a = h();
+          a !== void 0 && this.editor.chain().setNodeSelection(a).updateAttributes(this.name, {
+            width: r,
+            height: n
+          }).run();
+        },
+        onUpdate: y,
+        options: {
+          directions: e,
+          min: {
+            width: i,
+            height: l
+          },
+          preserveAspectRatio: o === !0
+        }
+      }), p = A.dom;
+      return p.style.visibility = "hidden", p.style.pointerEvents = "none", t.onload = () => {
+        p.style.visibility = "", p.style.pointerEvents = "";
+      }, A;
+    };
+  },
+  addCommands() {
+    return {
+      setImage: (e) => ({ commands: i }) => i.insertContent({
+        type: this.name,
+        attrs: e
+      })
+    };
+  },
+  addInputRules() {
+    return [
+      R({
+        find: z,
+        type: this.type,
+        getAttributes: (e) => {
+          const [, , i, l, o] = e;
+          return { src: l, alt: i, title: o };
+        }
+      })
+    ];
+  }
+}), H = _;
+export {
+  _ as Image,
+  H as default,
+  z as inputRegex
+};

package/dist/index-D49VHc9h.js

@@ -0,0 +1,237 @@
+import { E as s, M as y, g as l, m as d } from "./index-pYkcVgEL.js";
+var p = 20, a = (t, e = 0) => {
+  const r = [];
+  return !t.children.length || e > p || Array.from(t.children).forEach((n) => {
+    n.tagName === "SPAN" ? r.push(n) : n.children.length && r.push(...a(n, e + 1));
+  }), r;
+}, f = (t) => {
+  if (!t.children.length)
+    return;
+  const e = a(t);
+  e && e.forEach((r) => {
+    var n, o;
+    const i = r.getAttribute("style"), u = (o = (n = r.parentElement) == null ? void 0 : n.closest("span")) == null ? void 0 : o.getAttribute("style");
+    r.setAttribute("style", `${u};${i}`);
+  });
+}, 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", d(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, n) => {
+          if (r.isTextblock)
+            return !0;
+          r.marks.filter((o) => o.type === this.type).some((o) => Object.values(o.attrs).some((i) => !!i)) || t.removeMark(n, n + r.nodeSize, this.type);
+        }), !0;
+      }
+    };
+  }
+}), h = s.create({
+  name: "backgroundColor",
+  addOptions() {
+    return {
+      types: ["textStyle"]
+    };
+  },
+  addGlobalAttributes() {
+    return [
+      {
+        types: this.options.types,
+        attributes: {
+          backgroundColor: {
+            default: null,
+            parseHTML: (t) => {
+              var e;
+              const r = (e = l(t, "background-color")) != null ? e : t.style.backgroundColor;
+              return r?.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()
+    };
+  }
+}), S = s.create({
+  name: "color",
+  addOptions() {
+    return {
+      types: ["textStyle"]
+    };
+  },
+  addGlobalAttributes() {
+    return [
+      {
+        types: this.options.types,
+        attributes: {
+          color: {
+            default: null,
+            parseHTML: (t) => {
+              var e;
+              const r = (e = l(t, "color")) != null ? e : t.style.color;
+              return r?.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()
+    };
+  }
+}), g = s.create({
+  name: "fontFamily",
+  addOptions() {
+    return {
+      types: ["textStyle"]
+    };
+  },
+  addGlobalAttributes() {
+    return [
+      {
+        types: this.options.types,
+        attributes: {
+          fontFamily: {
+            default: null,
+            // Prefer the raw inline `style` attribute so unquoted or
+            // single-quoted multi-word names are preserved instead of being
+            // canonicalized by `element.style.fontFamily`, which forces double
+            // quotes that then get HTML-encoded to `"` on serialization.
+            parseHTML: (t) => {
+              var e;
+              return (e = l(t, "font-family")) != null ? e : 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()
+    };
+  }
+}), m = s.create({
+  name: "fontSize",
+  addOptions() {
+    return {
+      types: ["textStyle"]
+    };
+  },
+  addGlobalAttributes() {
+    return [
+      {
+        types: this.options.types,
+        attributes: {
+          fontSize: {
+            default: null,
+            // Prefer the raw inline `style` attribute so the original format
+            // is preserved instead of the canonicalized value returned by
+            // `element.style.fontSize`.
+            parseHTML: (t) => {
+              var e;
+              return (e = l(t, "font-size")) != null ? e : 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()
+    };
+  }
+}), x = s.create({
+  name: "lineHeight",
+  addOptions() {
+    return {
+      types: ["textStyle"]
+    };
+  },
+  addGlobalAttributes() {
+    return [
+      {
+        types: this.options.types,
+        attributes: {
+          lineHeight: {
+            default: null,
+            // Prefer the raw inline `style` attribute so the original format
+            // is preserved instead of the canonicalized value returned by
+            // `element.style.lineHeight`.
+            parseHTML: (t) => {
+              var e;
+              return (e = l(t, "line-height")) != null ? e : 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()
+    };
+  }
+}), v = s.create({
+  name: "textStyleKit",
+  addExtensions() {
+    const t = [];
+    return this.options.backgroundColor !== !1 && t.push(h.configure(this.options.backgroundColor)), this.options.color !== !1 && t.push(S.configure(this.options.color)), this.options.fontFamily !== !1 && t.push(g.configure(this.options.fontFamily)), this.options.fontSize !== !1 && t.push(m.configure(this.options.fontSize)), this.options.lineHeight !== !1 && t.push(x.configure(this.options.lineHeight)), this.options.textStyle !== !1 && t.push(c.configure(this.options.textStyle)), t;
+  }
+});
+export {
+  h as BackgroundColor,
+  S as Color,
+  g as FontFamily,
+  m as FontSize,
+  x as LineHeight,
+  c as TextStyle,
+  v as TextStyleKit
+};