react-hook-quill/dist/index.js

React Hook Quill is a lightweight wrapper for Quill, the rich text editor that does not interfere with the design of either React or Quill.

import D, { Delta as m } from "quill";
import { useRef as d, useEffect as y, useState as R } from "react";
const w = ({ setting: e }) => {
  const u = d(null), o = d(null);
  return y(() => {
    var p;
    if (e.containerRef.current && u.current === null) {
      const c = e.containerRef.current, l = c.appendChild(
        c.ownerDocument.createElement("div")
      );
      o.current = { parent: c };
      const s = new D(l, e.options);
      u.current = s, (p = e.setup) == null || p.call(e, u.current);
    }
    return () => {
      var c;
      if (u.current && ((c = e.cleanup) == null || c.call(e, u.current)), u.current = null, o.current) {
        for (; o.current.parent.lastChild; )
          o.current.parent.removeChild(o.current.parent.lastChild);
        o.current = null;
      }
    };
  }, [
    u,
    o,
    e
  ]), u;
}, v = (e, u = new m()) => {
  const o = d(null), p = (r) => {
    o.current ? r.setContents(o.current) : r.setContents(u);
  }, c = (r) => {
    o.current = r.editor.delta;
  }, [l, s] = R({
    containerRef: e.containerRef,
    options: { ...e.options },
    setup: (r) => {
      var t;
      p(r), (t = e.setup) == null || t.call(e, r);
    },
    cleanup: (r) => {
      var t;
      c(r), (t = e.cleanup) == null || t.call(e, r);
    }
  });
  return {
    persistentDeltaSetting: l,
    updateSetting: (r) => {
      s({
        containerRef: r.containerRef,
        options: { ...r.options },
        setup: (t) => {
          var f;
          p(t), (f = r.setup) == null || f.call(r, t);
        },
        cleanup: (t) => {
          var f;
          c(t), (f = r.cleanup) == null || f.call(r, t);
        }
      });
    }
  };
}, T = (e, u = new m()) => {
  const [o, p] = R(u), c = d(null), l = (n) => {
    n.setContents(o), c.current || (c.current = () => {
      p(n.editor.delta);
    }, n.on(D.events.TEXT_CHANGE, c.current));
  }, s = (n) => {
    c.current && (n.off(D.events.TEXT_CHANGE, c.current), c.current = null);
  }, [C, r] = R({
    containerRef: e.containerRef,
    options: { ...e.options },
    setup: (n) => {
      var a;
      l(n), (a = e.setup) == null || a.call(e, n);
    },
    cleanup: (n) => {
      var a;
      s(n), (a = e.cleanup) == null || a.call(e, n);
    }
  });
  return {
    delta: o,
    setDelta: p,
    syncDelta: (n, a) => {
      n !== null && (p(a), n == null || n.setContents(a));
    },
    syncDeltaSetting: C,
    updateSetting: (n) => {
      r({
        containerRef: n.containerRef,
        options: { ...n.options },
        setup: (a) => {
          var S;
          l(a), (S = n.setup) == null || S.call(n, a);
        },
        cleanup: n.cleanup
      });
    }
  };
};
export {
  v as usePersistentDelta,
  w as useQuill,
  T as useSyncDelta
};