@blockbite/ui 1.0.0

package/dist/node_modules/@wordpress/block-editor/build-module/components/block-list/block-crash-boundary.js

@@ -0,0 +1,19 @@
+import { Component as r } from "@wordpress/element";
+class e extends r {
+  constructor() {
+    super(...arguments), this.state = {
+      hasError: !1
+    };
+  }
+  componentDidCatch() {
+    this.setState({
+      hasError: !0
+    });
+  }
+  render() {
+    return this.state.hasError ? this.props.fallback : this.props.children;
+  }
+}
+export {
+  e as default
+};

package/dist/node_modules/@wordpress/block-editor/build-module/components/block-list/block-crash-warning.js

@@ -0,0 +1,12 @@
+import "../../../../i18n/build-module/sprintf.js";
+import "../../../../../tannin/index.js";
+import { __ as r } from "../../../../i18n/build-module/default-i18n.js";
+import o from "../warning/index.js";
+import { j as n } from "../../../../../react/jsx-runtime.js";
+const a = /* @__PURE__ */ n.jsx(o, {
+  className: "block-editor-block-list__block-crash-warning",
+  children: r("This block has encountered an error and cannot be previewed.")
+}), m = () => a;
+export {
+  m as default
+};

package/dist/node_modules/@wordpress/block-editor/build-module/components/block-list/block-html.js

@@ -0,0 +1,43 @@
+import u from "../../../../../react-autosize-textarea/lib/index.js";
+import { useState as p, useEffect as f } from "@wordpress/element";
+import "../../../../blocks/build-module/store/index.js";
+import { store as m } from "../../store/index.js";
+import { j as k } from "../../../../../react/jsx-runtime.js";
+import g from "../../../../data/build-module/components/use-select/index.js";
+import b from "../../../../data/build-module/components/use-dispatch/use-dispatch.js";
+import { getBlockInnerHTML as B, getSaveContent as x } from "../../../../blocks/build-module/api/serializer.js";
+import { getBlockAttributes as h } from "../../../../blocks/build-module/api/parser/get-block-attributes.js";
+import { validateBlock as C } from "../../../../blocks/build-module/api/validation/index.js";
+import { getBlockType as T } from "../../../../blocks/build-module/api/registration.js";
+function z({
+  clientId: r
+}) {
+  const [o, n] = p(""), e = g((t) => t(m).getBlock(r), [r]), {
+    updateBlock: a
+  } = b(m), c = () => {
+    const t = T(e.name);
+    if (!t)
+      return;
+    const s = h(t, o, e.attributes), i = o || x(t, s), [l] = o ? C({
+      ...e,
+      attributes: s,
+      originalContent: i
+    }) : [!0];
+    a(r, {
+      attributes: s,
+      originalContent: i,
+      isValid: l
+    }), o || n(i);
+  };
+  return f(() => {
+    n(B(e));
+  }, [e]), /* @__PURE__ */ k.jsx(u, {
+    className: "block-editor-block-list__block-html-textarea",
+    value: o,
+    onBlur: c,
+    onChange: (t) => n(t.target.value)
+  });
+}
+export {
+  z as default
+};

package/dist/node_modules/@wordpress/block-editor/build-module/components/block-list/block-invalid-warning.js

@@ -0,0 +1,99 @@
+import "../../../../i18n/build-module/sprintf.js";
+import "../../../../../tannin/index.js";
+import { _x as T, __ as r } from "../../../../i18n/build-module/default-i18n.js";
+import { Button as b, Modal as M } from "@wordpress/components";
+import { useState as g, useCallback as h, useMemo as B } from "@wordpress/element";
+import "../../../../blocks/build-module/store/index.js";
+import H from "../warning/index.js";
+import j from "../block-compare/index.js";
+import { store as C } from "../../store/index.js";
+import { j as c } from "../../../../../react/jsx-runtime.js";
+import L from "../../../../data/build-module/components/use-select/index.js";
+import R from "../../../../data/build-module/components/use-dispatch/use-dispatch.js";
+import { rawHandler as y } from "../../../../blocks/build-module/api/raw-handling/index.js";
+import { createBlock as s } from "../../../../blocks/build-module/api/factory.js";
+const u = (n) => y({
+  HTML: n.originalContent
+});
+function O({
+  clientId: n
+}) {
+  const {
+    block: o,
+    canInsertHTMLBlock: i,
+    canInsertClassicBlock: a
+  } = L((t) => {
+    const {
+      canInsertBlockType: k,
+      getBlock: x,
+      getBlockRootClientId: I
+    } = t(C), p = I(n);
+    return {
+      block: x(n),
+      canInsertHTMLBlock: k("core/html", p),
+      canInsertClassicBlock: k("core/freeform", p)
+    };
+  }, [n]), {
+    replaceBlock: l
+  } = R(C), [f, m] = g(!1), d = h(() => m(!1), []), e = B(() => ({
+    toClassic() {
+      const t = s("core/freeform", {
+        content: o.originalContent
+      });
+      return l(o.clientId, t);
+    },
+    toHTML() {
+      const t = s("core/html", {
+        content: o.originalContent
+      });
+      return l(o.clientId, t);
+    },
+    toBlocks() {
+      const t = u(o);
+      return l(o.clientId, t);
+    },
+    toRecoveredBlock() {
+      const t = s(o.name, o.attributes, o.innerBlocks);
+      return l(o.clientId, t);
+    }
+  }), [o, l]), v = B(() => [{
+    // translators: Button to fix block content
+    title: T("Resolve", "imperative verb"),
+    onClick: () => m(!0)
+  }, i && {
+    title: r("Convert to HTML"),
+    onClick: e.toHTML
+  }, a && {
+    title: r("Convert to Classic Block"),
+    onClick: e.toClassic
+  }].filter(Boolean), [i, a, e]);
+  return /* @__PURE__ */ c.jsxs(c.Fragment, {
+    children: [/* @__PURE__ */ c.jsx(H, {
+      actions: [/* @__PURE__ */ c.jsx(b, {
+        __next40pxDefaultSize: !0,
+        onClick: e.toRecoveredBlock,
+        variant: "primary",
+        children: r("Attempt recovery")
+      }, "recover")],
+      secondaryActions: v,
+      children: r("Block contains unexpected or invalid content.")
+    }), f && /* @__PURE__ */ c.jsx(M, {
+      title: (
+        // translators: Dialog title to fix block content
+        r("Resolve Block")
+      ),
+      onRequestClose: d,
+      className: "block-editor-block-compare",
+      children: /* @__PURE__ */ c.jsx(j, {
+        block: o,
+        onKeep: e.toHTML,
+        onConvert: e.toBlocks,
+        convertor: u,
+        convertButtonText: r("Convert to Blocks")
+      })
+    })]
+  });
+}
+export {
+  O as default
+};

package/dist/node_modules/@wordpress/block-editor/build-module/components/block-list/block.js

@@ -0,0 +1,474 @@
+import { clsx as G } from "../../../../../clsx/dist/clsx.js";
+import { memo as qe, useMemo as Ge, useContext as Je, RawHTML as Ke } from "@wordpress/element";
+import { store as Qe } from "../../../../blocks/build-module/store/index.js";
+import { withFilters as Xe } from "@wordpress/components";
+import Ye from "../block-edit/index.js";
+import Ze from "./block-invalid-warning.js";
+import et from "./block-crash-warning.js";
+import tt from "./block-crash-boundary.js";
+import ot from "./block-html.js";
+import { useBlockProps as lt } from "./use-block-props/index.js";
+import { store as W } from "../../store/index.js";
+import { useLayout as it } from "./layout.js";
+import { PrivateBlockContext as J } from "./private-block-context.js";
+import { unlock as st } from "../../lock-unlock.js";
+import { j as a } from "../../../../../react/jsx-runtime.js";
+import nt from "../../../../data/build-module/components/use-select/index.js";
+import { getBlockType as V, isReusableBlock as ct, hasBlockSupport as at, getDefaultBlockName as ie } from "../../../../blocks/build-module/api/registration.js";
+import { serializeRawBlock as rt } from "../../../../blocks/build-module/api/parser/serialize-raw-block.js";
+import dt from "../../../../dom/build-module/dom/safe-html.js";
+import mt from "../../../../compose/build-module/higher-order/compose.js";
+import ut from "../../../../data/build-module/components/with-dispatch/index.js";
+import { getBlockDefaultClassName as kt, getSaveContent as ft } from "../../../../blocks/build-module/api/serializer.js";
+import { isUnmodifiedDefaultBlock as se, isUnmodifiedBlock as ne } from "../../../../blocks/build-module/api/utils.js";
+import { switchToBlockType as ce, createBlock as pt } from "../../../../blocks/build-module/api/factory.js";
+function gt(r, e) {
+  const c = {
+    ...r,
+    ...e
+  };
+  return r?.hasOwnProperty("className") && e?.hasOwnProperty("className") && (c.className = G(r.className, e.className)), r?.hasOwnProperty("style") && e?.hasOwnProperty("style") && (c.style = {
+    ...r.style,
+    ...e.style
+  }), c;
+}
+function H({
+  children: r,
+  isHtml: e,
+  ...c
+}) {
+  return /* @__PURE__ */ a.jsx("div", {
+    ...lt(c, {
+      __unstableIsHtml: e
+    }),
+    children: r
+  });
+}
+function K({
+  block: {
+    __unstableBlockSource: r
+  },
+  mode: e,
+  isLocked: c,
+  canRemove: x,
+  clientId: b,
+  isSelected: I,
+  isSelectionEnabled: P,
+  className: A,
+  __unstableLayoutClassNames: O,
+  name: y,
+  isValid: k,
+  attributes: D,
+  wrapperProps: t,
+  setAttributes: s,
+  onReplace: l,
+  onRemove: f,
+  onInsertBlocksAfter: p,
+  onMerge: g,
+  toggleSelection: B
+}) {
+  var m;
+  const {
+    mayDisplayControls: v,
+    mayDisplayParentControls: j,
+    themeSupportsLayout: E,
+    ...M
+  } = Je(J), N = it() || {};
+  let h = /* @__PURE__ */ a.jsx(Ye, {
+    name: y,
+    isSelected: I,
+    attributes: D,
+    setAttributes: s,
+    insertBlocksAfter: c ? void 0 : p,
+    onReplace: x ? l : void 0,
+    onRemove: x ? f : void 0,
+    mergeBlocks: x ? g : void 0,
+    clientId: b,
+    isSelectionEnabled: P,
+    toggleSelection: B,
+    __unstableLayoutClassNames: O,
+    __unstableParentLayout: Object.keys(N).length ? N : void 0,
+    mayDisplayControls: v,
+    mayDisplayParentControls: j,
+    blockEditingMode: M.blockEditingMode,
+    isPreviewMode: M.isPreviewMode
+  });
+  const o = V(y);
+  o?.getEditWrapperProps && (t = gt(t, o.getEditWrapperProps(D)));
+  const i = t && !!t["data-align"] && !E, d = A?.includes("is-position-sticky");
+  i && (h = /* @__PURE__ */ a.jsx("div", {
+    className: G("wp-block", d && A),
+    "data-align": t["data-align"],
+    children: h
+  }));
+  let n;
+  if (k)
+    e === "html" ? n = /* @__PURE__ */ a.jsxs(a.Fragment, {
+      children: [/* @__PURE__ */ a.jsx("div", {
+        style: {
+          display: "none"
+        },
+        children: h
+      }), /* @__PURE__ */ a.jsx(H, {
+        isHtml: !0,
+        children: /* @__PURE__ */ a.jsx(ot, {
+          clientId: b
+        })
+      })]
+    }) : o?.apiVersion > 1 ? n = h : n = /* @__PURE__ */ a.jsx(H, {
+      children: h
+    });
+  else {
+    const S = r ? rt(r) : ft(o, D);
+    n = /* @__PURE__ */ a.jsxs(H, {
+      className: "has-warning",
+      children: [/* @__PURE__ */ a.jsx(Ze, {
+        clientId: b
+      }), /* @__PURE__ */ a.jsx(Ke, {
+        children: dt(S)
+      })]
+    });
+  }
+  const {
+    "data-align": u,
+    ...C
+  } = (m = t) !== null && m !== void 0 ? m : {}, L = {
+    ...C,
+    className: G(C.className, u && E && `align${u}`, !(u && d) && A)
+  };
+  return /* @__PURE__ */ a.jsx(J.Provider, {
+    value: {
+      wrapperProps: L,
+      isAligned: i,
+      ...M
+    },
+    children: /* @__PURE__ */ a.jsx(tt, {
+      fallback: /* @__PURE__ */ a.jsx(H, {
+        className: "has-warning",
+        children: /* @__PURE__ */ a.jsx(et, {})
+      }),
+      children: n
+    })
+  });
+}
+const Bt = ut((r, e, c) => {
+  const {
+    updateBlockAttributes: x,
+    insertBlocks: b,
+    mergeBlocks: I,
+    replaceBlocks: P,
+    toggleSelection: A,
+    __unstableMarkLastChangeAsPersistent: O,
+    moveBlocksToPosition: y,
+    removeBlock: k,
+    selectBlock: D
+  } = r(W);
+  return {
+    setAttributes(t) {
+      const {
+        getMultiSelectedBlockClientIds: s
+      } = c.select(W), l = s(), {
+        clientId: f,
+        attributes: p
+      } = e, g = l.length ? l : [f], B = typeof t == "function" ? t(p) : t;
+      x(g, B);
+    },
+    onInsertBlocks(t, s) {
+      const {
+        rootClientId: l
+      } = e;
+      b(t, s, l);
+    },
+    onInsertBlocksAfter(t) {
+      const {
+        clientId: s,
+        rootClientId: l
+      } = e, {
+        getBlockIndex: f
+      } = c.select(W), p = f(s);
+      b(t, p + 1, l);
+    },
+    onMerge(t) {
+      const {
+        clientId: s,
+        rootClientId: l
+      } = e, {
+        getPreviousBlockClientId: f,
+        getNextBlockClientId: p,
+        getBlock: g,
+        getBlockAttributes: B,
+        getBlockName: m,
+        getBlockOrder: v,
+        getBlockIndex: j,
+        getBlockRootClientId: E,
+        canInsertBlockType: M
+      } = c.select(W);
+      function N() {
+        const o = g(s), i = ie(), d = V(i);
+        if (m(s) !== i) {
+          const n = ce(o, i);
+          n && n.length && P(s, n);
+        } else if (se(o)) {
+          const n = p(s);
+          n && c.batch(() => {
+            k(s), D(n);
+          });
+        } else if (d.merge) {
+          const n = d.merge({}, o.attributes);
+          P([s], [pt(i, n)]);
+        }
+      }
+      function h(o, i = !0) {
+        const d = m(o), u = V(d).category === "text", C = E(o), L = v(o), [S] = L;
+        L.length === 1 && ne(g(S)) ? k(o) : u ? c.batch(() => {
+          if (M(m(S), C))
+            y([S], o, C, j(o));
+          else {
+            const R = ce(g(S), ie());
+            R && R.length && R.every((F) => M(F.name, C)) ? (b(R, j(o), C, i), k(S, !1)) : N();
+          }
+          !v(o).length && ne(g(o)) && k(o, !1);
+        }) : N();
+      }
+      if (t) {
+        if (l) {
+          const i = p(l);
+          if (i)
+            if (m(l) === m(i)) {
+              const d = B(l), n = B(i);
+              if (Object.keys(d).every((u) => d[u] === n[u])) {
+                c.batch(() => {
+                  y(v(i), i, l), k(i, !1);
+                });
+                return;
+              }
+            } else {
+              I(l, i);
+              return;
+            }
+        }
+        const o = p(s);
+        if (!o)
+          return;
+        v(o).length ? h(o, !1) : I(s, o);
+      } else {
+        const o = f(s);
+        if (o)
+          I(o, s);
+        else if (l) {
+          const i = f(l);
+          if (i && m(l) === m(i)) {
+            const d = B(l), n = B(i);
+            if (Object.keys(d).every((u) => d[u] === n[u])) {
+              c.batch(() => {
+                y(v(l), l, i), k(l, !1);
+              });
+              return;
+            }
+          }
+          h(l);
+        } else
+          N();
+      }
+    },
+    onReplace(t, s, l) {
+      t.length && !se(t[t.length - 1]) && O();
+      const f = t?.length === 1 && Array.isArray(t[0]) ? t[0] : t;
+      P([e.clientId], f, s, l);
+    },
+    onRemove() {
+      k(e.clientId);
+    },
+    toggleSelection(t) {
+      A(t);
+    }
+  };
+});
+K = mt(Bt, Xe("editor.BlockListBlock"))(K);
+function ht(r) {
+  const {
+    clientId: e,
+    rootClientId: c
+  } = r, x = nt((Q) => {
+    const {
+      isBlockSelected: ue,
+      getBlockMode: ke,
+      isSelectionEnabled: fe,
+      getTemplateLock: pe,
+      isSectionBlock: ge,
+      getBlockWithoutAttributes: Be,
+      getBlockAttributes: he,
+      canRemoveBlock: be,
+      canMoveBlock: ye,
+      getSettings: ve,
+      getTemporarilyEditingAsBlocks: Ce,
+      getBlockEditingMode: X,
+      getBlockName: Y,
+      isFirstMultiSelectedBlock: Se,
+      getMultiSelectedBlockClientIds: xe,
+      hasSelectedInnerBlock: Z,
+      getBlocksByName: Ie,
+      getBlockIndex: De,
+      isBlockMultiSelected: Me,
+      isBlockSubtreeDisabled: Ne,
+      isBlockHighlighted: Pe,
+      __unstableIsFullySelected: Ae,
+      __unstableSelectionHasUnmergeableBlock: Te,
+      isBlockBeingDragged: je,
+      isDragging: Ee,
+      __unstableHasActiveBlockOverlayActive: Le,
+      getSelectedBlocksInitialCaretPosition: Re
+    } = st(Q(W)), U = Be(e);
+    if (!U)
+      return;
+    const {
+      hasBlockSupport: Oe,
+      getActiveBlockVariation: we
+    } = Q(Qe), $ = he(e), {
+      name: T,
+      isValid: We
+    } = U, w = V(T), {
+      supportsLayout: _e,
+      isPreviewMode: ee
+    } = ve(), te = w?.apiVersion > 1, oe = {
+      isPreviewMode: ee,
+      blockWithoutAttributes: U,
+      name: T,
+      attributes: $,
+      isValid: We,
+      themeSupportsLayout: _e,
+      index: De(e),
+      isReusable: ct(w),
+      className: te ? $.className : void 0,
+      defaultClassName: te ? kt(T) : void 0,
+      blockTitle: w?.title
+    };
+    if (ee)
+      return oe;
+    const z = ue(e), He = be(e), Ve = ye(e), Fe = we(T, $), le = Me(e), Ue = Z(e, !0), _ = X(e), q = at(T, "multiple", !0) ? [] : Ie(T), $e = q.length && q[0] !== e;
+    return {
+      ...oe,
+      mode: ke(e),
+      isSelectionEnabled: fe(),
+      isLocked: !!pe(c),
+      isSectionBlock: ge(e),
+      canRemove: He,
+      canMove: Ve,
+      isSelected: z,
+      isTemporarilyEditingAsBlocks: Ce() === e,
+      blockEditingMode: _,
+      mayDisplayControls: z || Se(e) && xe().every((ze) => Y(ze) === T),
+      mayDisplayParentControls: Oe(Y(e), "__experimentalExposeControlsToChildren", !1) && Z(e),
+      blockApiVersion: w?.apiVersion || 1,
+      blockTitle: Fe?.title || w?.title,
+      isSubtreeDisabled: _ === "disabled" && Ne(e),
+      hasOverlay: Le(e) && !Ee(),
+      initialPosition: z ? Re() : void 0,
+      isHighlighted: Pe(e),
+      isMultiSelected: le,
+      isPartiallySelected: le && !Ae() && !Te(),
+      isDragging: je(e),
+      hasChildSelected: Ue,
+      isEditingDisabled: _ === "disabled",
+      hasEditableOutline: _ !== "disabled" && X(c) === "disabled",
+      originalBlockClientId: $e ? q[0] : !1
+    };
+  }, [e, c]), {
+    isPreviewMode: b,
+    // Fill values that end up as a public API and may not be defined in
+    // preview mode.
+    mode: I = "visual",
+    isSelectionEnabled: P = !1,
+    isLocked: A = !1,
+    canRemove: O = !1,
+    canMove: y = !1,
+    blockWithoutAttributes: k,
+    name: D,
+    attributes: t,
+    isValid: s,
+    isSelected: l = !1,
+    themeSupportsLayout: f,
+    isTemporarilyEditingAsBlocks: p,
+    blockEditingMode: g,
+    mayDisplayControls: B,
+    mayDisplayParentControls: m,
+    index: v,
+    blockApiVersion: j,
+    blockTitle: E,
+    isSubtreeDisabled: M,
+    hasOverlay: N,
+    initialPosition: h,
+    isHighlighted: o,
+    isMultiSelected: i,
+    isPartiallySelected: d,
+    isReusable: n,
+    isDragging: u,
+    hasChildSelected: C,
+    isSectionBlock: L,
+    isEditingDisabled: S,
+    hasEditableOutline: R,
+    className: F,
+    defaultClassName: ae,
+    originalBlockClientId: re
+  } = x, de = Ge(() => ({
+    ...k,
+    attributes: t
+  }), [k, t]);
+  if (!x)
+    return null;
+  const me = {
+    isPreviewMode: b,
+    clientId: e,
+    className: F,
+    index: v,
+    mode: I,
+    name: D,
+    blockApiVersion: j,
+    blockTitle: E,
+    isSelected: l,
+    isSubtreeDisabled: M,
+    hasOverlay: N,
+    initialPosition: h,
+    blockEditingMode: g,
+    isHighlighted: o,
+    isMultiSelected: i,
+    isPartiallySelected: d,
+    isReusable: n,
+    isDragging: u,
+    hasChildSelected: C,
+    isSectionBlock: L,
+    isEditingDisabled: S,
+    hasEditableOutline: R,
+    isTemporarilyEditingAsBlocks: p,
+    defaultClassName: ae,
+    mayDisplayControls: B,
+    mayDisplayParentControls: m,
+    originalBlockClientId: re,
+    themeSupportsLayout: f,
+    canMove: y
+  };
+  return /* @__PURE__ */ a.jsx(J.Provider, {
+    value: me,
+    children: /* @__PURE__ */ a.jsx(K, {
+      ...r,
+      mode: I,
+      isSelectionEnabled: P,
+      isLocked: A,
+      canRemove: O,
+      canMove: y,
+      // Users of the editor.BlockListBlock filter used to be able
+      // to access the block prop. Ideally these blocks would rely
+      // on the clientId prop only. This is kept for backward
+      // compatibility reasons.
+      block: de,
+      name: D,
+      attributes: t,
+      isValid: s,
+      isSelected: l
+    })
+  });
+}
+const zt = qe(ht);
+export {
+  zt as default
+};