@dooherceg/tiptap-controlled-editor-with-table 0.0.7 → 0.0.9

package/dist/node_modules/@radix-ui/react-roving-focus/dist/index.js

@@ -0,0 +1,183 @@
+import * as c from "react";
+import { composeEventHandlers as p } from "../../primitive/dist/index.js";
+import { createCollection as V } from "../../react-collection/dist/index.js";
+import { useComposedRefs as j } from "../../react-compose-refs/dist/index.js";
+import { createContextScope as z } from "../../react-context/dist/index.js";
+import { useId as q } from "../../react-id/dist/index.js";
+import { Primitive as G } from "../../react-primitive/dist/index.js";
+import { useCallbackRef as J } from "../../react-use-callback-ref/dist/index.js";
+import { useControllableState as Q } from "../../react-use-controllable-state/dist/index.js";
+import { useDirection as W } from "../../react-direction/dist/index.js";
+import { jsx as d } from "react/jsx-runtime";
+var y = "rovingFocusGroup.onEntryFocus", X = { bubbles: !1, cancelable: !0 }, I = "RovingFocusGroup", [D, N, Z] = V(I), [$, Fe] = z(
+  I,
+  [Z]
+), [ee, oe] = $(I), O = c.forwardRef(
+  (e, r) => /* @__PURE__ */ d(D.Provider, { scope: e.__scopeRovingFocusGroup, children: /* @__PURE__ */ d(D.Slot, { scope: e.__scopeRovingFocusGroup, children: /* @__PURE__ */ d(te, { ...e, ref: r }) }) })
+);
+O.displayName = I;
+var te = c.forwardRef((e, r) => {
+  const {
+    __scopeRovingFocusGroup: s,
+    orientation: o,
+    loop: T = !1,
+    dir: w,
+    currentTabStopId: v,
+    defaultCurrentTabStopId: C,
+    onCurrentTabStopIdChange: S,
+    onEntryFocus: m,
+    preventScrollOnEntryFocus: u = !1,
+    ...b
+  } = e, F = c.useRef(null), g = j(r, F), R = W(w), [E, t] = Q({
+    prop: v,
+    defaultProp: C ?? null,
+    onChange: S,
+    caller: I
+  }), [i, h] = c.useState(!1), a = J(m), l = N(s), A = c.useRef(!1), [L, P] = c.useState(0);
+  return c.useEffect(() => {
+    const n = F.current;
+    if (n)
+      return n.addEventListener(y, a), () => n.removeEventListener(y, a);
+  }, [a]), /* @__PURE__ */ d(
+    ee,
+    {
+      scope: s,
+      orientation: o,
+      dir: R,
+      loop: T,
+      currentTabStopId: E,
+      onItemFocus: c.useCallback(
+        (n) => t(n),
+        [t]
+      ),
+      onItemShiftTab: c.useCallback(() => h(!0), []),
+      onFocusableItemAdd: c.useCallback(
+        () => P((n) => n + 1),
+        []
+      ),
+      onFocusableItemRemove: c.useCallback(
+        () => P((n) => n - 1),
+        []
+      ),
+      children: /* @__PURE__ */ d(
+        G.div,
+        {
+          tabIndex: i || L === 0 ? -1 : 0,
+          "data-orientation": o,
+          ...b,
+          ref: g,
+          style: { outline: "none", ...e.style },
+          onMouseDown: p(e.onMouseDown, () => {
+            A.current = !0;
+          }),
+          onFocus: p(e.onFocus, (n) => {
+            const U = !A.current;
+            if (n.target === n.currentTarget && U && !i) {
+              const x = new CustomEvent(y, X);
+              if (n.currentTarget.dispatchEvent(x), !x.defaultPrevented) {
+                const _ = l().filter((f) => f.focusable), B = _.find((f) => f.active), Y = _.find((f) => f.id === E), H = [B, Y, ..._].filter(
+                  Boolean
+                ).map((f) => f.ref.current);
+                k(H, u);
+              }
+            }
+            A.current = !1;
+          }),
+          onBlur: p(e.onBlur, () => h(!1))
+        }
+      )
+    }
+  );
+}), K = "RovingFocusGroupItem", M = c.forwardRef(
+  (e, r) => {
+    const {
+      __scopeRovingFocusGroup: s,
+      focusable: o = !0,
+      active: T = !1,
+      tabStopId: w,
+      children: v,
+      ...C
+    } = e, S = q(), m = w || S, u = oe(K, s), b = u.currentTabStopId === m, F = N(s), { onFocusableItemAdd: g, onFocusableItemRemove: R, currentTabStopId: E } = u;
+    return c.useEffect(() => {
+      if (o)
+        return g(), () => R();
+    }, [o, g, R]), /* @__PURE__ */ d(
+      D.ItemSlot,
+      {
+        scope: s,
+        id: m,
+        focusable: o,
+        active: T,
+        children: /* @__PURE__ */ d(
+          G.span,
+          {
+            tabIndex: b ? 0 : -1,
+            "data-orientation": u.orientation,
+            ...C,
+            ref: r,
+            onMouseDown: p(e.onMouseDown, (t) => {
+              o ? u.onItemFocus(m) : t.preventDefault();
+            }),
+            onFocus: p(e.onFocus, () => u.onItemFocus(m)),
+            onKeyDown: p(e.onKeyDown, (t) => {
+              if (t.key === "Tab" && t.shiftKey) {
+                u.onItemShiftTab();
+                return;
+              }
+              if (t.target !== t.currentTarget) return;
+              const i = ce(t, u.orientation, u.dir);
+              if (i !== void 0) {
+                if (t.metaKey || t.ctrlKey || t.altKey || t.shiftKey) return;
+                t.preventDefault();
+                let a = F().filter((l) => l.focusable).map((l) => l.ref.current);
+                if (i === "last") a.reverse();
+                else if (i === "prev" || i === "next") {
+                  i === "prev" && a.reverse();
+                  const l = a.indexOf(t.currentTarget);
+                  a = u.loop ? se(a, l + 1) : a.slice(l + 1);
+                }
+                setTimeout(() => k(a));
+              }
+            }),
+            children: typeof v == "function" ? v({ isCurrentTabStop: b, hasTabStop: E != null }) : v
+          }
+        )
+      }
+    );
+  }
+);
+M.displayName = K;
+var re = {
+  ArrowLeft: "prev",
+  ArrowUp: "prev",
+  ArrowRight: "next",
+  ArrowDown: "next",
+  PageUp: "first",
+  Home: "first",
+  PageDown: "last",
+  End: "last"
+};
+function ne(e, r) {
+  return r !== "rtl" ? e : e === "ArrowLeft" ? "ArrowRight" : e === "ArrowRight" ? "ArrowLeft" : e;
+}
+function ce(e, r, s) {
+  const o = ne(e.key, s);
+  if (!(r === "vertical" && ["ArrowLeft", "ArrowRight"].includes(o)) && !(r === "horizontal" && ["ArrowUp", "ArrowDown"].includes(o)))
+    return re[o];
+}
+function k(e, r = !1) {
+  const s = document.activeElement;
+  for (const o of e)
+    if (o === s || (o.focus({ preventScroll: r }), document.activeElement !== s)) return;
+}
+function se(e, r) {
+  return e.map((s, o) => e[(r + o) % e.length]);
+}
+var ge = O, Re = M;
+export {
+  Re as Item,
+  ge as Root,
+  O as RovingFocusGroup,
+  M as RovingFocusGroupItem,
+  Fe as createRovingFocusGroupScope
+};

package/dist/node_modules/@radix-ui/react-slot/dist/index.js

@@ -0,0 +1,49 @@
+import * as l from "react";
+import { composeRefs as m } from "../../react-compose-refs/dist/index.js";
+import { jsx as u } from "react/jsx-runtime";
+// @__NO_SIDE_EFFECTS__
+function b(e) {
+  const r = /* @__PURE__ */ y(e), t = l.forwardRef((o, n) => {
+    const { children: i, ...c } = o, s = l.Children.toArray(i), a = s.find(E);
+    if (a) {
+      const f = a.props.children, d = s.map((p) => p === a ? l.Children.count(f) > 1 ? l.Children.only(null) : l.isValidElement(f) ? f.props.children : null : p);
+      return /* @__PURE__ */ u(r, { ...c, ref: n, children: l.isValidElement(f) ? l.cloneElement(f, void 0, d) : null });
+    }
+    return /* @__PURE__ */ u(r, { ...c, ref: n, children: i });
+  });
+  return t.displayName = `${e}.Slot`, t;
+}
+// @__NO_SIDE_EFFECTS__
+function y(e) {
+  const r = l.forwardRef((t, o) => {
+    const { children: n, ...i } = t;
+    if (l.isValidElement(n)) {
+      const c = S(n), s = C(i, n.props);
+      return n.type !== l.Fragment && (s.ref = o ? m(o, c) : c), l.cloneElement(n, s);
+    }
+    return l.Children.count(n) > 1 ? l.Children.only(null) : null;
+  });
+  return r.displayName = `${e}.SlotClone`, r;
+}
+var g = Symbol("radix.slottable");
+function E(e) {
+  return l.isValidElement(e) && typeof e.type == "function" && "__radixId" in e.type && e.type.__radixId === g;
+}
+function C(e, r) {
+  const t = { ...r };
+  for (const o in r) {
+    const n = e[o], i = r[o];
+    /^on[A-Z]/.test(o) ? n && i ? t[o] = (...s) => {
+      const a = i(...s);
+      return n(...s), a;
+    } : n && (t[o] = n) : o === "style" ? t[o] = { ...n, ...i } : o === "className" && (t[o] = [n, i].filter(Boolean).join(" "));
+  }
+  return { ...e, ...t };
+}
+function S(e) {
+  let r = Object.getOwnPropertyDescriptor(e.props, "ref")?.get, t = r && "isReactWarning" in r && r.isReactWarning;
+  return t ? e.ref : (r = Object.getOwnPropertyDescriptor(e, "ref")?.get, t = r && "isReactWarning" in r && r.isReactWarning, t ? e.props.ref : e.props.ref || e.ref);
+}
+export {
+  b as createSlot
+};

package/dist/node_modules/@radix-ui/react-use-callback-ref/dist/index.js

@@ -0,0 +1,10 @@
+import * as e from "react";
+function c(r) {
+  const t = e.useRef(r);
+  return e.useEffect(() => {
+    t.current = r;
+  }), e.useMemo(() => (...u) => t.current?.(...u), []);
+}
+export {
+  c as useCallbackRef
+};

package/dist/node_modules/@radix-ui/react-use-controllable-state/dist/index.js

@@ -0,0 +1,52 @@
+import * as o from "react";
+import { useLayoutEffect as m } from "../../react-use-layout-effect/dist/index.js";
+var v = o[" useInsertionEffect ".trim().toString()] || m;
+function w({
+  prop: e,
+  defaultProp: s,
+  onChange: t = () => {
+  },
+  caller: f
+}) {
+  const [u, c, i] = R({
+    defaultProp: s,
+    onChange: t
+  }), n = e !== void 0, a = n ? e : u;
+  {
+    const r = o.useRef(e !== void 0);
+    o.useEffect(() => {
+      const l = r.current;
+      l !== n && console.warn(
+        `${f} is changing from ${l ? "controlled" : "uncontrolled"} to ${n ? "controlled" : "uncontrolled"}. Components should not switch from controlled to uncontrolled (or vice versa). Decide between using a controlled or uncontrolled value for the lifetime of the component.`
+      ), r.current = n;
+    }, [n, f]);
+  }
+  const d = o.useCallback(
+    (r) => {
+      if (n) {
+        const l = C(r) ? r(e) : r;
+        l !== e && i.current?.(l);
+      } else
+        c(r);
+    },
+    [n, e, c, i]
+  );
+  return [a, d];
+}
+function R({
+  defaultProp: e,
+  onChange: s
+}) {
+  const [t, f] = o.useState(e), u = o.useRef(t), c = o.useRef(s);
+  return v(() => {
+    c.current = s;
+  }, [s]), o.useEffect(() => {
+    u.current !== t && (c.current?.(t), u.current = t);
+  }, [t, u]), [t, f, c];
+}
+function C(e) {
+  return typeof e == "function";
+}
+export {
+  w as useControllableState
+};

package/dist/node_modules/@radix-ui/react-use-escape-keydown/dist/index.js

@@ -0,0 +1,14 @@
+import * as r from "react";
+import { useCallbackRef as s } from "../../react-use-callback-ref/dist/index.js";
+function p(n, e = globalThis?.document) {
+  const t = s(n);
+  r.useEffect(() => {
+    const o = (a) => {
+      a.key === "Escape" && t(a);
+    };
+    return e.addEventListener("keydown", o, { capture: !0 }), () => e.removeEventListener("keydown", o, { capture: !0 });
+  }, [t, e]);
+}
+export {
+  p as useEscapeKeydown
+};

package/dist/node_modules/@radix-ui/react-use-layout-effect/dist/index.js

@@ -0,0 +1,6 @@
+import * as t from "react";
+var e = globalThis?.document ? t.useLayoutEffect : () => {
+};
+export {
+  e as useLayoutEffect
+};

package/dist/node_modules/@radix-ui/react-use-size/dist/index.js

@@ -0,0 +1,27 @@
+import * as h from "react";
+import { useLayoutEffect as z } from "../../react-use-layout-effect/dist/index.js";
+function c(r) {
+  const [d, e] = h.useState(void 0);
+  return z(() => {
+    if (r) {
+      e({ width: r.offsetWidth, height: r.offsetHeight });
+      const f = new ResizeObserver((i) => {
+        if (!Array.isArray(i) || !i.length)
+          return;
+        const b = i[0];
+        let o, t;
+        if ("borderBoxSize" in b) {
+          const s = b.borderBoxSize, u = Array.isArray(s) ? s[0] : s;
+          o = u.inlineSize, t = u.blockSize;
+        } else
+          o = r.offsetWidth, t = r.offsetHeight;
+        e({ width: o, height: t });
+      });
+      return f.observe(r, { box: "border-box" }), () => f.unobserve(r);
+    } else
+      e(void 0);
+  }, [r]), d;
+}
+export {
+  c as useSize
+};

package/dist/node_modules/@tiptap/extension-highlight/dist/index.js

@@ -0,0 +1,84 @@
+import { Mark as a, markPasteRule as s, markInputRule as l, mergeAttributes as u } from "@tiptap/core";
+var h = /(?:^|\s)(==(?!\s+==)((?:[^=]+))==(?!\s+==))$/, d = /(?:^|\s)(==(?!\s+==)((?:[^=]+))==(?!\s+==))/g, m = a.create({
+  name: "highlight",
+  addOptions() {
+    return {
+      multicolor: !1,
+      HTMLAttributes: {}
+    };
+  },
+  addAttributes() {
+    return this.options.multicolor ? {
+      color: {
+        default: null,
+        parseHTML: (r) => r.getAttribute("data-color") || r.style.backgroundColor,
+        renderHTML: (r) => r.color ? {
+          "data-color": r.color,
+          style: `background-color: ${r.color}; color: inherit`
+        } : {}
+      }
+    } : {};
+  },
+  parseHTML() {
+    return [
+      {
+        tag: "mark"
+      }
+    ];
+  },
+  renderHTML({ HTMLAttributes: r }) {
+    return ["mark", u(this.options.HTMLAttributes, r), 0];
+  },
+  renderMarkdown: (r, t) => `==${t.renderChildren(r)}==`,
+  parseMarkdown: (r, t) => t.applyMark("highlight", t.parseInline(r.tokens || [])),
+  markdownTokenizer: {
+    name: "highlight",
+    level: "inline",
+    start: (r) => r.indexOf("=="),
+    tokenize(r, t, i) {
+      const e = /^(==)([^=]+)(==)/.exec(r);
+      if (e) {
+        const n = e[2].trim(), o = i.inlineTokens(n);
+        return {
+          type: "highlight",
+          raw: e[0],
+          text: n,
+          tokens: o
+        };
+      }
+    }
+  },
+  addCommands() {
+    return {
+      setHighlight: (r) => ({ commands: t }) => t.setMark(this.name, r),
+      toggleHighlight: (r) => ({ commands: t }) => t.toggleMark(this.name, r),
+      unsetHighlight: () => ({ commands: r }) => r.unsetMark(this.name)
+    };
+  },
+  addKeyboardShortcuts() {
+    return {
+      "Mod-Shift-h": () => this.editor.commands.toggleHighlight()
+    };
+  },
+  addInputRules() {
+    return [
+      l({
+        find: h,
+        type: this.type
+      })
+    ];
+  },
+  addPasteRules() {
+    return [
+      s({
+        find: d,
+        type: this.type
+      })
+    ];
+  }
+});
+export {
+  m as Highlight,
+  h as inputRegex,
+  d as pasteRegex
+};

package/dist/node_modules/@tiptap/extension-horizontal-rule/dist/index.js

@@ -0,0 +1,57 @@
+import { Node as f, nodeInputRule as m, canInsertNode as h, isNodeSelection as T, mergeAttributes as y } from "@tiptap/core";
+import { TextSelection as s, NodeSelection as k } from "prosemirror-state";
+var A = f.create({
+  name: "horizontalRule",
+  addOptions() {
+    return {
+      HTMLAttributes: {},
+      nextNodeType: "paragraph"
+    };
+  },
+  group: "block",
+  parseHTML() {
+    return [{ tag: "hr" }];
+  },
+  renderHTML({ HTMLAttributes: o }) {
+    return ["hr", y(this.options.HTMLAttributes, o)];
+  },
+  markdownTokenName: "hr",
+  parseMarkdown: (o, n) => n.createNode("horizontalRule"),
+  renderMarkdown: () => "---",
+  addCommands() {
+    return {
+      setHorizontalRule: () => ({ chain: o, state: n }) => {
+        if (!h(n, n.schema.nodes[this.name]))
+          return !1;
+        const { selection: i } = n, { $to: l } = i, r = o();
+        return T(i) ? r.insertContentAt(l.pos, {
+          type: this.name
+        }) : r.insertContent({ type: this.name }), r.command(({ state: u, tr: e, dispatch: p }) => {
+          if (p) {
+            const { $to: t } = e.selection, a = t.end();
+            if (t.nodeAfter)
+              t.nodeAfter.isTextblock ? e.setSelection(s.create(e.doc, t.pos + 1)) : t.nodeAfter.isBlock ? e.setSelection(k.create(e.doc, t.pos)) : e.setSelection(s.create(e.doc, t.pos));
+            else {
+              const d = u.schema.nodes[this.options.nextNodeType] || t.parent.type.contentMatch.defaultType, c = d?.create();
+              c && (e.insert(a, c), e.setSelection(s.create(e.doc, a + 1)));
+            }
+            e.scrollIntoView();
+          }
+          return !0;
+        }).run();
+      }
+    };
+  },
+  addInputRules() {
+    return [
+      m({
+        find: /^(?:---|—-|___\s|\*\*\*\s)$/,
+        type: this.type
+      })
+    ];
+  }
+}), S = A;
+export {
+  A as HorizontalRule,
+  S as default
+};

package/dist/node_modules/@tiptap/extension-image/dist/index.js

@@ -0,0 +1,128 @@
+import { Node as h, nodeInputRule as m, ResizableNodeView as f, mergeAttributes as g } from "@tiptap/core";
+var b = /(?:^|\s)(!\[(.+|:?)]\((\S+)(?:(?:\s+)["'](\S+)["'])?\))$/, y = h.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: t }) {
+    return ["img", g(this.options.HTMLAttributes, t)];
+  },
+  parseMarkdown: (t, e) => e.createNode("image", {
+    src: t.href,
+    title: t.title,
+    alt: t.text
+  }),
+  renderMarkdown: (t) => {
+    var e, l, a, o, u, d;
+    const i = (l = (e = t.attrs) == null ? void 0 : e.src) != null ? l : "", c = (o = (a = t.attrs) == null ? void 0 : a.alt) != null ? o : "", r = (d = (u = t.attrs) == null ? void 0 : u.title) != null ? d : "";
+    return r ? `![${c}](${i} "${r}")` : `![${c}](${i})`;
+  },
+  addNodeView() {
+    if (!this.options.resize || !this.options.resize.enabled || typeof document > "u" || !this.editor.isEditable)
+      return null;
+    const { directions: t, minWidth: e, minHeight: l, alwaysPreserveAspectRatio: a } = this.options.resize;
+    return ({ node: o, getPos: u, HTMLAttributes: d }) => {
+      const i = document.createElement("img");
+      Object.entries(d).forEach(([n, s]) => {
+        if (s != null)
+          switch (n) {
+            case "width":
+            case "height":
+              break;
+            default:
+              i.setAttribute(n, s);
+              break;
+          }
+      }), i.src = d.src;
+      const c = new f({
+        element: i,
+        node: o,
+        getPos: u,
+        onResize: (n, s) => {
+          i.style.width = `${n}px`, i.style.height = `${s}px`;
+        },
+        onCommit: (n, s) => {
+          const p = u();
+          p !== void 0 && this.editor.chain().setNodeSelection(p).updateAttributes(this.name, {
+            width: n,
+            height: s
+          }).run();
+        },
+        onUpdate: (n, s, p) => n.type === o.type,
+        options: {
+          directions: t,
+          min: {
+            width: e,
+            height: l
+          },
+          preserveAspectRatio: a === !0
+        }
+      }), r = c.dom;
+      return r.style.visibility = "hidden", r.style.pointerEvents = "none", i.onload = () => {
+        r.style.visibility = "", r.style.pointerEvents = "";
+      }, c;
+    };
+  },
+  addCommands() {
+    return {
+      setImage: (t) => ({ commands: e }) => e.insertContent({
+        type: this.name,
+        attrs: t
+      })
+    };
+  },
+  addInputRules() {
+    return [
+      m({
+        find: b,
+        type: this.type,
+        getAttributes: (t) => {
+          const [, , e, l, a] = t;
+          return { src: l, alt: e, title: a };
+        }
+      })
+    ];
+  }
+});
+export {
+  y as Image,
+  b as inputRegex
+};