ablok-components 0.3.33 → 0.3.34

package/dist/index-Bk6yOA7Y.mjs

@@ -0,0 +1,94 @@
+import { d as g, aC as r, aB as n, aE as _ } from "./index-Ki1Egcx9.mjs";
+var s = (e, t) => {
+  if (e === "slot")
+    return 0;
+  if (e instanceof Function)
+    return e(t);
+  const { children: u, ...p } = t ?? {};
+  if (e === "svg")
+    throw new Error("SVG elements are not supported in the JSX syntax, use the array syntax instead");
+  return [e, p, u];
+}, a = /(?:^|\s)(\*\*(?!\s+\*\*)((?:[^*]+))\*\*(?!\s+\*\*))$/, o = /(?:^|\s)(\*\*(?!\s+\*\*)((?:[^*]+))\*\*(?!\s+\*\*))/g, d = /(?:^|\s)(__(?!\s+__)((?:[^_]+))__(?!\s+__))$/, l = /(?:^|\s)(__(?!\s+__)((?:[^_]+))__(?!\s+__))/g, i = g.create({
+  name: "bold",
+  addOptions() {
+    return {
+      HTMLAttributes: {}
+    };
+  },
+  parseHTML() {
+    return [
+      {
+        tag: "strong"
+      },
+      {
+        tag: "b",
+        getAttrs: (e) => e.style.fontWeight !== "normal" && null
+      },
+      {
+        style: "font-weight=400",
+        clearMark: (e) => e.type.name === this.name
+      },
+      {
+        style: "font-weight",
+        getAttrs: (e) => /^(bold(er)?|[5-9]\d{2,})$/.test(e) && null
+      }
+    ];
+  },
+  renderHTML({ HTMLAttributes: e }) {
+    return /* @__PURE__ */ s("strong", { ..._(this.options.HTMLAttributes, e), children: /* @__PURE__ */ s("slot", {}) });
+  },
+  markdownTokenName: "strong",
+  parseMarkdown: (e, t) => t.applyMark("bold", t.parseInline(e.tokens || [])),
+  renderMarkdown: (e, t) => `**${t.renderChildren(e)}**`,
+  addCommands() {
+    return {
+      setBold: () => ({ commands: e }) => e.setMark(this.name),
+      toggleBold: () => ({ commands: e }) => e.toggleMark(this.name),
+      unsetBold: () => ({ commands: e }) => e.unsetMark(this.name)
+    };
+  },
+  addKeyboardShortcuts() {
+    return {
+      "Mod-b": () => this.editor.commands.toggleBold(),
+      "Mod-B": () => this.editor.commands.toggleBold()
+    };
+  },
+  addInputRules() {
+    return [
+      n({
+        find: a,
+        type: this.type
+      }),
+      n({
+        find: d,
+        type: this.type
+      })
+    ];
+  },
+  addPasteRules() {
+    return [
+      r({
+        find: o,
+        type: this.type
+      }),
+      r({
+        find: l,
+        type: this.type
+      })
+    ];
+  }
+}), m = i;
+const y = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  Bold: i,
+  default: m,
+  starInputRegex: a,
+  starPasteRegex: o,
+  underscoreInputRegex: d,
+  underscorePasteRegex: l
+}, Symbol.toStringTag, { value: "Module" }));
+export {
+  i as B,
+  s as h,
+  y as i
+};

package/dist/index-BzE6-pPu.mjs

@@ -0,0 +1,580 @@
+import { E as f, M as S, N as x } from "./index-Ki1Egcx9.mjs";
+import { C as H, a as J, b as $, F as G, I as K, c as Q, d as X, e as Y, f as Z, P as ee, R as te, g as se, T as re, h as ne, i as ae, j as ie, k as oe, l as de, m as ue, n as le, o as ce, p as pe, q as he, r as me, s as ge, t as ve, u as fe, v as Se, w as xe, x as ye, y as we, z as be, A as Ce, B as Ne, D as _e, G as Ee, H as Me, J as Pe, K as ke, L as Ae, O as Re, Q as Oe, S as Te, U as De, V as Ve, W as je, X as qe, Y as Fe, Z as Ie, _ as Be, $ as We, a0 as Le, a1 as Ue, a2 as ze, a3 as He, a4 as Je, a5 as $e, a6 as Ge, a7 as Ke, a8 as Qe, a9 as Xe, aa as Ye, ab as Ze, ac as et, ad as tt, p as st, ae as rt, af as nt, ag as at, ah as it, ai as ot, aj as dt, ak as ut, al as lt, am as ct, an as pt, ao as ht, ap as mt, aq as gt, ar as vt, as as ft, at as St, au as xt, av as yt, aw as wt, ax as bt, ay as Ct, az as Nt, aA as _t, aB as Et, aC as Mt, aD as Pt, aE as kt, aF as At, aG as Rt, aH as Ot, aI as Tt, aJ as Dt, aK as Vt, aL as jt, aM as qt, aN as Ft, aO as It, aP as Bt, aQ as Wt, aR as Lt, aS as Ut, aT as zt, aU as Ht, aV as Jt, aW as $t, aX as Gt, aY as Kt, aZ as Qt, a_ as Xt, a$ as Yt } from "./index-Ki1Egcx9.mjs";
+import { defineComponent as o, markRaw as p, h as d, ref as h, getCurrentInstance as y, watchEffect as w, nextTick as b, unref as C, onBeforeUnmount as m, toRaw as N, reactive as _, render as u, shallowRef as E, onMounted as M, customRef as P, provide as l } from "vue";
+function c(e) {
+  return P((t, s) => ({
+    get() {
+      return t(), e;
+    },
+    set(r) {
+      e = r, requestAnimationFrame(() => {
+        requestAnimationFrame(() => {
+          s();
+        });
+      });
+    }
+  }));
+}
+var k = class extends f {
+  constructor(e = {}) {
+    return super(e), this.contentComponent = null, this.appContext = null, this.reactiveState = c(this.view.state), this.reactiveExtensionStorage = c(this.extensionStorage), this.on("beforeTransaction", ({ nextState: t }) => {
+      this.reactiveState.value = t, this.reactiveExtensionStorage.value = this.extensionStorage;
+    }), p(this);
+  }
+  get state() {
+    return this.reactiveState ? this.reactiveState.value : this.view.state;
+  }
+  get storage() {
+    return this.reactiveExtensionStorage ? this.reactiveExtensionStorage.value : super.storage;
+  }
+  /**
+   * Register a ProseMirror plugin.
+   */
+  registerPlugin(e, t) {
+    const s = super.registerPlugin(e, t);
+    return this.reactiveState && (this.reactiveState.value = s), s;
+  }
+  /**
+   * Unregister a ProseMirror plugin.
+   */
+  unregisterPlugin(e) {
+    const t = super.unregisterPlugin(e);
+    return this.reactiveState && t && (this.reactiveState.value = t), t;
+  }
+}, D = o({
+  name: "EditorContent",
+  props: {
+    editor: {
+      default: null,
+      type: Object
+    }
+  },
+  setup(e) {
+    const t = h(), s = y();
+    return w(() => {
+      const r = e.editor;
+      r && r.options.element && t.value && b(() => {
+        var n;
+        if (!t.value || !((n = r.view.dom) != null && n.parentNode))
+          return;
+        const a = C(t.value);
+        t.value.append(...r.view.dom.parentNode.childNodes), r.contentComponent = s.ctx._, s && (r.appContext = {
+          ...s.appContext,
+          // Vue internally uses prototype chain to forward/shadow injects across the entire component chain
+          // so don't use object spread operator or 'Object.assign' and just set `provides` as is on editor's appContext
+          // @ts-expect-error forward instance's 'provides' into appContext
+          provides: s.provides
+        }), r.setOptions({
+          element: a
+        }), r.createNodeViews();
+      });
+    }), m(() => {
+      const r = e.editor;
+      r && (r.contentComponent = null, r.appContext = null);
+    }), { rootEl: t };
+  },
+  render() {
+    return d("div", {
+      ref: (e) => {
+        this.rootEl = e;
+      }
+    });
+  }
+}), V = o({
+  name: "NodeViewContent",
+  props: {
+    as: {
+      type: String,
+      default: "div"
+    }
+  },
+  render() {
+    return d(this.as, {
+      style: {
+        whiteSpace: "pre-wrap"
+      },
+      "data-node-view-content": ""
+    });
+  }
+}), j = o({
+  name: "NodeViewWrapper",
+  props: {
+    as: {
+      type: String,
+      default: "div"
+    }
+  },
+  inject: ["onDragStart", "decorationClasses"],
+  render() {
+    var e, t;
+    return d(
+      this.as,
+      {
+        // @ts-ignore
+        class: this.decorationClasses,
+        style: {
+          whiteSpace: "normal"
+        },
+        "data-node-view-wrapper": "",
+        // @ts-ignore (https://github.com/vuejs/vue-next/issues/3031)
+        onDragstart: this.onDragStart
+      },
+      (t = (e = this.$slots).default) == null ? void 0 : t.call(e)
+    );
+  }
+}), q = (e = {}) => {
+  const t = E();
+  return M(() => {
+    t.value = new k(e);
+  }), m(() => {
+    var s, r, n, a;
+    const i = (r = (s = t.value) == null ? void 0 : s.view.dom) == null ? void 0 : r.parentNode, v = i?.cloneNode(!0);
+    (n = i?.parentNode) == null || n.replaceChild(v, i), (a = t.value) == null || a.destroy();
+  }), t;
+}, g = class {
+  constructor(e, { props: t = {}, editor: s }) {
+    this.destroyed = !1, this.editor = s, this.component = p(e), this.el = document.createElement("div"), this.props = _(t), this.renderedComponent = this.renderComponent();
+  }
+  get element() {
+    return this.renderedComponent.el;
+  }
+  get ref() {
+    var e, t, s, r;
+    return (t = (e = this.renderedComponent.vNode) == null ? void 0 : e.component) != null && t.exposed ? this.renderedComponent.vNode.component.exposed : (r = (s = this.renderedComponent.vNode) == null ? void 0 : s.component) == null ? void 0 : r.proxy;
+  }
+  renderComponent() {
+    if (this.destroyed)
+      return this.renderedComponent;
+    let e = d(this.component, this.props);
+    return this.editor.appContext && (e.appContext = this.editor.appContext), typeof document < "u" && this.el && u(e, this.el), { vNode: e, destroy: () => {
+      this.el && u(null, this.el), this.el = null, e = null;
+    }, el: this.el ? this.el.firstElementChild : null };
+  }
+  updateProps(e = {}) {
+    this.destroyed || (Object.entries(e).forEach(([t, s]) => {
+      this.props[t] = s;
+    }), this.renderComponent());
+  }
+  destroy() {
+    this.destroyed || (this.destroyed = !0, this.renderedComponent.destroy());
+  }
+}, F = {
+  editor: {
+    type: Object,
+    required: !0
+  },
+  mark: {
+    type: Object,
+    required: !0
+  },
+  extension: {
+    type: Object,
+    required: !0
+  },
+  inline: {
+    type: Boolean,
+    required: !0
+  },
+  view: {
+    type: Object,
+    required: !0
+  },
+  updateAttributes: {
+    type: Function,
+    required: !0
+  },
+  HTMLAttributes: {
+    type: Object,
+    required: !0
+  }
+}, I = o({
+  name: "MarkViewContent",
+  props: {
+    as: {
+      type: String,
+      default: "span"
+    }
+  },
+  render() {
+    return d(this.as, {
+      style: {
+        whiteSpace: "inherit"
+      },
+      "data-mark-view-content": ""
+    });
+  }
+}), A = class extends S {
+  constructor(e, t, s) {
+    super(e, t, s);
+    const r = { ...t, updateAttributes: this.updateAttributes.bind(this) }, n = o({
+      extends: { ...e },
+      props: Object.keys(r),
+      template: this.component.template,
+      setup: (a) => {
+        var i;
+        return (i = e.setup) == null ? void 0 : i.call(e, a, {
+          expose: () => {
+          }
+        });
+      },
+      // Add support for scoped styles
+      __scopeId: e.__scopeId,
+      __cssModules: e.__cssModules,
+      __name: e.__name,
+      __file: e.__file
+    });
+    this.renderer = new g(n, {
+      editor: this.editor,
+      props: r
+    });
+  }
+  get dom() {
+    return this.renderer.element;
+  }
+  get contentDOM() {
+    return this.dom.querySelector("[data-mark-view-content]");
+  }
+  updateAttributes(e) {
+    const t = N(this.mark);
+    super.updateAttributes(e, t);
+  }
+  destroy() {
+    this.renderer.destroy();
+  }
+};
+function B(e, t = {}) {
+  return (s) => s.editor.contentComponent ? new A(e, s, t) : {};
+}
+var W = {
+  editor: {
+    type: Object,
+    required: !0
+  },
+  node: {
+    type: Object,
+    required: !0
+  },
+  decorations: {
+    type: Object,
+    required: !0
+  },
+  selected: {
+    type: Boolean,
+    required: !0
+  },
+  extension: {
+    type: Object,
+    required: !0
+  },
+  getPos: {
+    type: Function,
+    required: !0
+  },
+  updateAttributes: {
+    type: Function,
+    required: !0
+  },
+  deleteNode: {
+    type: Function,
+    required: !0
+  },
+  view: {
+    type: Object,
+    required: !0
+  },
+  innerDecorations: {
+    type: Object,
+    required: !0
+  },
+  HTMLAttributes: {
+    type: Object,
+    required: !0
+  }
+}, R = class extends x {
+  constructor() {
+    super(...arguments), this.cachedExtensionWithSyncedStorage = null;
+  }
+  /**
+   * Returns a proxy of the extension that redirects storage access to the editor's mutable storage.
+   * This preserves the original prototype chain (instanceof checks, methods like configure/extend work).
+   * Cached to avoid proxy creation on every update.
+   */
+  get extensionWithSyncedStorage() {
+    if (!this.cachedExtensionWithSyncedStorage) {
+      const e = this.editor, t = this.extension;
+      this.cachedExtensionWithSyncedStorage = new Proxy(t, {
+        get(s, r, n) {
+          var a;
+          return r === "storage" ? (a = e.storage[t.name]) != null ? a : {} : Reflect.get(s, r, n);
+        }
+      });
+    }
+    return this.cachedExtensionWithSyncedStorage;
+  }
+  mount() {
+    const e = {
+      editor: this.editor,
+      node: this.node,
+      decorations: this.decorations,
+      innerDecorations: this.innerDecorations,
+      view: this.view,
+      selected: !1,
+      extension: this.extensionWithSyncedStorage,
+      HTMLAttributes: this.HTMLAttributes,
+      getPos: () => this.getPos(),
+      updateAttributes: (r = {}) => this.updateAttributes(r),
+      deleteNode: () => this.deleteNode()
+    }, t = this.onDragStart.bind(this);
+    this.decorationClasses = h(this.getDecorationClasses());
+    const s = o({
+      extends: { ...this.component },
+      props: Object.keys(e),
+      template: this.component.template,
+      setup: (r) => {
+        var n, a;
+        return l("onDragStart", t), l("decorationClasses", this.decorationClasses), (a = (n = this.component).setup) == null ? void 0 : a.call(n, r, {
+          expose: () => {
+          }
+        });
+      },
+      // add support for scoped styles
+      // @ts-ignore
+      // eslint-disable-next-line
+      __scopeId: this.component.__scopeId,
+      // add support for CSS Modules
+      // @ts-ignore
+      // eslint-disable-next-line
+      __cssModules: this.component.__cssModules,
+      // add support for vue devtools
+      // @ts-ignore
+      // eslint-disable-next-line
+      __name: this.component.__name,
+      // @ts-ignore
+      // eslint-disable-next-line
+      __file: this.component.__file
+    });
+    this.handleSelectionUpdate = this.handleSelectionUpdate.bind(this), this.editor.on("selectionUpdate", this.handleSelectionUpdate), this.renderer = new g(s, {
+      editor: this.editor,
+      props: e
+    });
+  }
+  /**
+   * Return the DOM element.
+   * This is the element that will be used to display the node view.
+   */
+  get dom() {
+    if (!this.renderer.element || !this.renderer.element.hasAttribute("data-node-view-wrapper"))
+      throw Error("Please use the NodeViewWrapper component for your node view.");
+    return this.renderer.element;
+  }
+  /**
+   * Return the content DOM element.
+   * This is the element that will be used to display the rich-text content of the node.
+   */
+  get contentDOM() {
+    return this.node.isLeaf ? null : this.dom.querySelector("[data-node-view-content]");
+  }
+  /**
+   * On editor selection update, check if the node is selected.
+   * If it is, call `selectNode`, otherwise call `deselectNode`.
+   */
+  handleSelectionUpdate() {
+    const { from: e, to: t } = this.editor.state.selection, s = this.getPos();
+    if (typeof s == "number")
+      if (e <= s && t >= s + this.node.nodeSize) {
+        if (this.renderer.props.selected)
+          return;
+        this.selectNode();
+      } else {
+        if (!this.renderer.props.selected)
+          return;
+        this.deselectNode();
+      }
+  }
+  /**
+   * On update, update the React component.
+   * To prevent unnecessary updates, the `update` option can be used.
+   */
+  update(e, t, s) {
+    const r = (n) => {
+      this.decorationClasses.value = this.getDecorationClasses(), this.renderer.updateProps(n);
+    };
+    if (typeof this.options.update == "function") {
+      const n = this.node, a = this.decorations, i = this.innerDecorations;
+      return this.node = e, this.decorations = t, this.innerDecorations = s, this.options.update({
+        oldNode: n,
+        oldDecorations: a,
+        newNode: e,
+        newDecorations: t,
+        oldInnerDecorations: i,
+        innerDecorations: s,
+        updateProps: () => r({ node: e, decorations: t, innerDecorations: s, extension: this.extensionWithSyncedStorage })
+      });
+    }
+    return e.type !== this.node.type ? !1 : (e === this.node && this.decorations === t && this.innerDecorations === s || (this.node = e, this.decorations = t, this.innerDecorations = s, r({ node: e, decorations: t, innerDecorations: s, extension: this.extensionWithSyncedStorage })), !0);
+  }
+  /**
+   * Select the node.
+   * Add the `selected` prop and the `ProseMirror-selectednode` class.
+   */
+  selectNode() {
+    this.renderer.updateProps({
+      selected: !0
+    }), this.renderer.element && this.renderer.element.classList.add("ProseMirror-selectednode");
+  }
+  /**
+   * Deselect the node.
+   * Remove the `selected` prop and the `ProseMirror-selectednode` class.
+   */
+  deselectNode() {
+    this.renderer.updateProps({
+      selected: !1
+    }), this.renderer.element && this.renderer.element.classList.remove("ProseMirror-selectednode");
+  }
+  getDecorationClasses() {
+    return this.decorations.flatMap((e) => e.type.attrs.class).join(" ");
+  }
+  destroy() {
+    this.renderer.destroy(), this.editor.off("selectionUpdate", this.handleSelectionUpdate);
+  }
+};
+function L(e, t) {
+  return (s) => {
+    if (!s.editor.contentComponent)
+      return {};
+    const r = typeof e == "function" && "__vccOpts" in e ? e.__vccOpts : e;
+    return new R(r, s, t);
+  };
+}
+export {
+  H as CommandManager,
+  k as Editor,
+  D as EditorContent,
+  J as Extendable,
+  $ as Extension,
+  G as Fragment,
+  K as InputRule,
+  Q as MappablePosition,
+  X as Mark,
+  S as MarkView,
+  I as MarkViewContent,
+  Y as Node,
+  Z as NodePos,
+  x as NodeView,
+  V as NodeViewContent,
+  j as NodeViewWrapper,
+  ee as PasteRule,
+  te as ResizableNodeView,
+  se as ResizableNodeview,
+  re as Tracker,
+  A as VueMarkView,
+  B as VueMarkViewRenderer,
+  L as VueNodeViewRenderer,
+  g as VueRenderer,
+  ne as callOrReturn,
+  ae as canInsertNode,
+  ie as combineTransactionSteps,
+  oe as commands,
+  de as createAtomBlockMarkdownSpec,
+  ue as createBlockMarkdownSpec,
+  le as createChainableState,
+  ce as createDocument,
+  pe as createElement,
+  he as createInlineMarkdownSpec,
+  me as createMappablePosition,
+  ge as createNodeFromContent,
+  ve as createStyleTag,
+  fe as defaultBlockAt,
+  Se as deleteProps,
+  xe as elementFromString,
+  ye as escapeForRegEx,
+  we as extensions,
+  be as findChildren,
+  Ce as findChildrenInRange,
+  Ne as findDuplicates,
+  _e as findParentNode,
+  Ee as findParentNodeClosestToPos,
+  Me as flattenExtensions,
+  Pe as fromString,
+  ke as generateHTML,
+  Ae as generateJSON,
+  Re as generateText,
+  Oe as getAttributes,
+  Te as getAttributesFromExtensions,
+  De as getChangedRanges,
+  Ve as getDebugJSON,
+  je as getExtensionField,
+  qe as getHTMLFromFragment,
+  Fe as getMarkAttributes,
+  Ie as getMarkRange,
+  Be as getMarkType,
+  We as getMarksBetween,
+  Le as getNodeAtPosition,
+  Ue as getNodeAttributes,
+  ze as getNodeType,
+  He as getRenderedAttributes,
+  Je as getSchema,
+  $e as getSchemaByResolvedExtensions,
+  Ge as getSchemaTypeByName,
+  Ke as getSchemaTypeNameByName,
+  Qe as getSplittedAttributes,
+  Xe as getText,
+  Ye as getTextBetween,
+  Ze as getTextContentFromNodes,
+  et as getTextSerializersFromSchema,
+  tt as getUpdatedPosition,
+  st as h,
+  rt as injectExtensionAttributesToParseRule,
+  nt as inputRulesPlugin,
+  at as isActive,
+  it as isAndroid,
+  ot as isAtEndOfNode,
+  dt as isAtStartOfNode,
+  ut as isEmptyObject,
+  lt as isExtensionRulesEnabled,
+  ct as isFirefox,
+  pt as isFunction,
+  ht as isList,
+  mt as isMacOS,
+  gt as isMarkActive,
+  vt as isNodeActive,
+  ft as isNodeEmpty,
+  St as isNodeSelection,
+  xt as isNumber,
+  yt as isPlainObject,
+  wt as isRegExp,
+  bt as isSafari,
+  Ct as isString,
+  Nt as isTextSelection,
+  _t as isiOS,
+  Et as markInputRule,
+  Mt as markPasteRule,
+  F as markViewProps,
+  Pt as markdown,
+  kt as mergeAttributes,
+  At as mergeDeep,
+  Rt as minMax,
+  Ot as nodeInputRule,
+  Tt as nodePasteRule,
+  W as nodeViewProps,
+  Dt as objectIncludes,
+  Vt as parseAttributes,
+  jt as parseIndentedBlocks,
+  qt as pasteRulesPlugin,
+  Ft as posToDOMRect,
+  It as removeDuplicates,
+  Bt as renderNestedMarkdownContent,
+  Wt as resolveExtensions,
+  Lt as resolveFocusPosition,
+  Ut as rewriteUnknownContent,
+  zt as selectionToInsertionEnd,
+  Ht as serializeAttributes,
+  Jt as sortExtensions,
+  $t as splitExtensions,
+  Gt as textInputRule,
+  Kt as textPasteRule,
+  Qt as textblockTypeInputRule,
+  Xt as updateMarkViewAttributes,
+  q as useEditor,
+  Yt as wrappingInputRule
+};