@blockbite/ui 1.0.4 → 2.0.0

package/dist/node_modules/@wordpress/block-editor/build-module/layouts/flex.js

@@ -0,0 +1,255 @@
+import "../../../i18n/build-module/sprintf.js";
+import "../../../../tannin/index.js";
+import { __ as s } from "../../../i18n/build-module/default-i18n.js";
+import { Flex as y, FlexItem as j, __experimentalToggleGroupControl as d, __experimentalToggleGroupControlOptionIcon as g, ToggleControl as v } from "@wordpress/components";
+import { appendSelectors as S, getBlockGapCSS as z } from "./utils.js";
+import { getGapCSSValue as A } from "../hooks/gap.js";
+import { shouldSkipSerialization as k } from "../hooks/utils.js";
+import { LAYOUT_DEFINITIONS as O } from "./definitions.js";
+import { j as n } from "../../../../react/jsx-runtime.js";
+import F from "../components/block-controls/index.js";
+import { JustifyContentControl as J } from "../components/justify-content-control/index.js";
+import V from "../../../icons/build-module/library/justify-left.js";
+import B from "../../../icons/build-module/library/justify-center.js";
+import G from "../../../icons/build-module/library/justify-right.js";
+import I from "../../../icons/build-module/library/justify-space-between.js";
+import L from "../../../icons/build-module/library/justify-stretch.js";
+import { BlockVerticalAlignmentControl as W } from "../components/block-vertical-alignment-control/index.js";
+import N from "../../../icons/build-module/library/arrow-right.js";
+import T from "../../../icons/build-module/library/arrow-down.js";
+const $ = {
+  left: "flex-start",
+  right: "flex-end",
+  center: "center",
+  "space-between": "space-between"
+}, b = {
+  left: "flex-start",
+  right: "flex-end",
+  center: "center",
+  stretch: "stretch"
+}, C = {
+  top: "flex-start",
+  center: "center",
+  bottom: "flex-end",
+  stretch: "stretch",
+  "space-between": "space-between"
+}, M = ["wrap", "nowrap"], pt = {
+  name: "flex",
+  label: s("Flex"),
+  inspectorControls: function({
+    layout: e = {},
+    onChange: t,
+    layoutBlockSupport: r = {}
+  }) {
+    const {
+      allowOrientation: i = !0,
+      allowJustification: l = !0
+    } = r;
+    return /* @__PURE__ */ n.jsxs(n.Fragment, {
+      children: [/* @__PURE__ */ n.jsxs(y, {
+        children: [l && /* @__PURE__ */ n.jsx(j, {
+          children: /* @__PURE__ */ n.jsx(w, {
+            layout: e,
+            onChange: t
+          })
+        }), i && /* @__PURE__ */ n.jsx(j, {
+          children: /* @__PURE__ */ n.jsx(H, {
+            layout: e,
+            onChange: t
+          })
+        })]
+      }), /* @__PURE__ */ n.jsx(D, {
+        layout: e,
+        onChange: t
+      })]
+    });
+  },
+  toolBarControls: function({
+    layout: e = {},
+    onChange: t,
+    layoutBlockSupport: r
+  }) {
+    const {
+      allowVerticalAlignment: i = !0,
+      allowJustification: l = !0
+    } = r;
+    return !l && !i ? null : /* @__PURE__ */ n.jsxs(F, {
+      group: "block",
+      __experimentalShareWithChildBlocks: !0,
+      children: [l && /* @__PURE__ */ n.jsx(w, {
+        layout: e,
+        onChange: t,
+        isToolbar: !0
+      }), i && /* @__PURE__ */ n.jsx(P, {
+        layout: e,
+        onChange: t
+      })]
+    });
+  },
+  getLayoutStyle: function({
+    selector: e,
+    layout: t,
+    style: r,
+    blockName: i,
+    hasBlockGapSupport: l,
+    layoutDefinitions: a = O
+  }) {
+    const {
+      orientation: c = "horizontal"
+    } = t, p = r?.spacing?.blockGap && !k(i, "spacing", "blockGap") ? A(r?.spacing?.blockGap, "0.5em") : void 0, m = $[t.justifyContent], u = M.includes(t.flexWrap) ? t.flexWrap : "wrap", h = C[t.verticalAlignment], _ = b[t.justifyContent] || b.left;
+    let x = "";
+    const f = [];
+    return u && u !== "wrap" && f.push(`flex-wrap: ${u}`), c === "horizontal" ? (h && f.push(`align-items: ${h}`), m && f.push(`justify-content: ${m}`)) : (h && f.push(`justify-content: ${h}`), f.push("flex-direction: column"), f.push(`align-items: ${_}`)), f.length && (x = `${S(e)} {
+				${f.join("; ")};
+			}`), l && p && (x += z(e, a, "flex", p)), x;
+  },
+  getOrientation(o) {
+    const {
+      orientation: e = "horizontal"
+    } = o;
+    return e;
+  },
+  getAlignments() {
+    return [];
+  }
+};
+function P({
+  layout: o,
+  onChange: e
+}) {
+  const {
+    orientation: t = "horizontal"
+  } = o, r = t === "horizontal" ? C.center : C.top, {
+    verticalAlignment: i = r
+  } = o, l = (a) => {
+    e({
+      ...o,
+      verticalAlignment: a
+    });
+  };
+  return /* @__PURE__ */ n.jsx(W, {
+    onChange: l,
+    value: i,
+    controls: t === "horizontal" ? ["top", "center", "bottom", "stretch"] : ["top", "center", "bottom", "space-between"]
+  });
+}
+const R = {
+  placement: "bottom-start"
+};
+function w({
+  layout: o,
+  onChange: e,
+  isToolbar: t = !1
+}) {
+  const {
+    justifyContent: r = "left",
+    orientation: i = "horizontal"
+  } = o, l = (p) => {
+    e({
+      ...o,
+      justifyContent: p
+    });
+  }, a = ["left", "center", "right"];
+  if (i === "horizontal" ? a.push("space-between") : a.push("stretch"), t)
+    return /* @__PURE__ */ n.jsx(J, {
+      allowedControls: a,
+      value: r,
+      onChange: l,
+      popoverProps: R
+    });
+  const c = [{
+    value: "left",
+    icon: V,
+    label: s("Justify items left")
+  }, {
+    value: "center",
+    icon: B,
+    label: s("Justify items center")
+  }, {
+    value: "right",
+    icon: G,
+    label: s("Justify items right")
+  }];
+  return i === "horizontal" ? c.push({
+    value: "space-between",
+    icon: I,
+    label: s("Space between items")
+  }) : c.push({
+    value: "stretch",
+    icon: L,
+    label: s("Stretch items")
+  }), /* @__PURE__ */ n.jsx(d, {
+    __next40pxDefaultSize: !0,
+    __nextHasNoMarginBottom: !0,
+    label: s("Justification"),
+    value: r,
+    onChange: l,
+    className: "block-editor-hooks__flex-layout-justification-controls",
+    children: c.map(({
+      value: p,
+      icon: m,
+      label: u
+    }) => /* @__PURE__ */ n.jsx(g, {
+      value: p,
+      icon: m,
+      label: u
+    }, p))
+  });
+}
+function D({
+  layout: o,
+  onChange: e
+}) {
+  const {
+    flexWrap: t = "wrap"
+  } = o;
+  return /* @__PURE__ */ n.jsx(v, {
+    __nextHasNoMarginBottom: !0,
+    label: s("Allow to wrap to multiple lines"),
+    onChange: (r) => {
+      e({
+        ...o,
+        flexWrap: r ? "wrap" : "nowrap"
+      });
+    },
+    checked: t === "wrap"
+  });
+}
+function H({
+  layout: o,
+  onChange: e
+}) {
+  const {
+    orientation: t = "horizontal",
+    verticalAlignment: r,
+    justifyContent: i
+  } = o;
+  return /* @__PURE__ */ n.jsxs(d, {
+    __next40pxDefaultSize: !0,
+    __nextHasNoMarginBottom: !0,
+    className: "block-editor-hooks__flex-layout-orientation-controls",
+    label: s("Orientation"),
+    value: t,
+    onChange: (l) => {
+      let a = r, c = i;
+      return l === "horizontal" ? (r === "space-between" && (a = "center"), i === "stretch" && (c = "left")) : (r === "stretch" && (a = "top"), i === "space-between" && (c = "left")), e({
+        ...o,
+        orientation: l,
+        verticalAlignment: a,
+        justifyContent: c
+      });
+    },
+    children: [/* @__PURE__ */ n.jsx(g, {
+      icon: N,
+      value: "horizontal",
+      label: s("Horizontal")
+    }), /* @__PURE__ */ n.jsx(g, {
+      icon: T,
+      value: "vertical",
+      label: s("Vertical")
+    })]
+  });
+}
+export {
+  pt as default
+};

package/dist/node_modules/@wordpress/block-editor/build-module/layouts/flow.js

@@ -0,0 +1,67 @@
+import "../../../i18n/build-module/sprintf.js";
+import "../../../../tannin/index.js";
+import { __ as m } from "../../../i18n/build-module/default-i18n.js";
+import { getAlignmentsInfo as u, getBlockGapCSS as p } from "./utils.js";
+import { getGapCSSValue as f } from "../hooks/gap.js";
+import { shouldSkipSerialization as c } from "../hooks/utils.js";
+import { LAYOUT_DEFINITIONS as g } from "./definitions.js";
+const I = {
+  name: "default",
+  label: m("Flow"),
+  inspectorControls: function() {
+    return null;
+  },
+  toolBarControls: function() {
+    return null;
+  },
+  getLayoutStyle: function({
+    selector: r,
+    style: o,
+    blockName: t,
+    hasBlockGapSupport: e,
+    layoutDefinitions: a = g
+  }) {
+    const i = f(o?.spacing?.blockGap);
+    let l = "";
+    c(t, "spacing", "blockGap") || (i?.top ? l = f(i?.top) : typeof i == "string" && (l = f(i)));
+    let s = "";
+    return e && l && (s += p(r, a, "default", l)), s;
+  },
+  getOrientation() {
+    return "vertical";
+  },
+  getAlignments(n, r) {
+    const o = u(n);
+    if (n.alignments !== void 0)
+      return n.alignments.includes("none") || n.alignments.unshift("none"), n.alignments.map((e) => ({
+        name: e,
+        info: o[e]
+      }));
+    const t = [{
+      name: "left"
+    }, {
+      name: "center"
+    }, {
+      name: "right"
+    }];
+    if (!r) {
+      const {
+        contentSize: e,
+        wideSize: a
+      } = n;
+      e && t.unshift({
+        name: "full"
+      }), a && t.unshift({
+        name: "wide",
+        info: o.wide
+      });
+    }
+    return t.unshift({
+      name: "none",
+      info: o.none
+    }), t;
+  }
+};
+export {
+  I as default
+};

package/dist/node_modules/@wordpress/block-editor/build-module/layouts/grid.js

@@ -0,0 +1,291 @@
+import "../../../i18n/build-module/sprintf.js";
+import "../../../../tannin/index.js";
+import { __ as s } from "../../../i18n/build-module/default-i18n.js";
+import { __experimentalVStack as y, __experimentalToggleGroupControl as I, __experimentalToggleGroupControlOption as w, BaseControl as g, Flex as v, FlexItem as h, __experimentalNumberControl as b, RangeControl as G, __experimentalParseQuantityAndUnitFromRawValue as E, __experimentalUnitControl as S } from "@wordpress/components";
+import { useState as _ } from "@wordpress/element";
+import { appendSelectors as M, getBlockGapCSS as L } from "./utils.js";
+import { getGapCSSValue as V } from "../hooks/gap.js";
+import { shouldSkipSerialization as F } from "../hooks/utils.js";
+import { LAYOUT_DEFINITIONS as k } from "./definitions.js";
+import { j as e } from "../../../../react/jsx-runtime.js";
+const z = {
+  px: 600,
+  "%": 100,
+  vw: 100,
+  vh: 100,
+  em: 38,
+  rem: 38,
+  svw: 100,
+  lvw: 100,
+  dvw: 100,
+  svh: 100,
+  lvh: 100,
+  dvh: 100,
+  vi: 100,
+  svi: 100,
+  lvi: 100,
+  dvi: 100,
+  vb: 100,
+  svb: 100,
+  lvb: 100,
+  dvb: 100,
+  vmin: 100,
+  svmin: 100,
+  lvmin: 100,
+  dvmin: 100,
+  vmax: 100,
+  svmax: 100,
+  lvmax: 100,
+  dvmax: 100
+}, N = [{
+  value: "px",
+  label: "px",
+  default: 0
+}, {
+  value: "rem",
+  label: "rem",
+  default: 0
+}, {
+  value: "em",
+  label: "em",
+  default: 0
+}], X = {
+  name: "grid",
+  label: s("Grid"),
+  inspectorControls: function({
+    layout: t = {},
+    onChange: a,
+    layoutBlockSupport: c = {}
+  }) {
+    const {
+      allowSizingOnChildren: m = !1
+    } = c, p = window.__experimentalEnableGridInteractivity || !!t?.columnCount, u = window.__experimentalEnableGridInteractivity || !t?.columnCount;
+    return /* @__PURE__ */ e.jsxs(e.Fragment, {
+      children: [/* @__PURE__ */ e.jsx(B, {
+        layout: t,
+        onChange: a
+      }), /* @__PURE__ */ e.jsxs(y, {
+        spacing: 4,
+        children: [p && /* @__PURE__ */ e.jsx(W, {
+          layout: t,
+          onChange: a,
+          allowSizingOnChildren: m
+        }), u && /* @__PURE__ */ e.jsx(T, {
+          layout: t,
+          onChange: a
+        })]
+      })]
+    });
+  },
+  toolBarControls: function() {
+    return null;
+  },
+  getLayoutStyle: function({
+    selector: t,
+    layout: a,
+    style: c,
+    blockName: m,
+    hasBlockGapSupport: p,
+    layoutDefinitions: u = k
+  }) {
+    const {
+      minimumColumnWidth: n = null,
+      columnCount: i = null,
+      rowCount: d = null
+    } = a;
+    if (process.env.NODE_ENV === "development") {
+      if (n && typeof n != "string")
+        throw new Error("minimumColumnWidth must be a string");
+      if (i && typeof i != "number")
+        throw new Error("columnCount must be a number");
+      if (d && typeof d != "number")
+        throw new Error("rowCount must be a number");
+    }
+    const x = c?.spacing?.blockGap && !F(m, "spacing", "blockGap") ? V(c?.spacing?.blockGap, "0.5em") : void 0;
+    let l = "";
+    const r = [];
+    if (n && i > 0) {
+      const f = `max(${n}, ( 100% - (${x || "1.2rem"}*${i - 1}) ) / ${i})`;
+      r.push(`grid-template-columns: repeat(auto-fill, minmax(${f}, 1fr))`, "container-type: inline-size"), d && r.push(`grid-template-rows: repeat(${d}, minmax(1rem, auto))`);
+    } else i ? (r.push(`grid-template-columns: repeat(${i}, minmax(0, 1fr))`), d && r.push(`grid-template-rows: repeat(${d}, minmax(1rem, auto))`)) : r.push(`grid-template-columns: repeat(auto-fill, minmax(min(${n || "12rem"}, 100%), 1fr))`, "container-type: inline-size");
+    return r.length && (l = `${M(t)} { ${r.join("; ")}; }`), p && x && (l += L(t, u, "grid", x)), l;
+  },
+  getOrientation() {
+    return "horizontal";
+  },
+  getAlignments() {
+    return [];
+  }
+};
+function T({
+  layout: o,
+  onChange: t
+}) {
+  const {
+    minimumColumnWidth: a,
+    columnCount: c,
+    isManualPlacement: m
+  } = o, u = a || (m || c ? null : "12rem"), [n, i = "rem"] = E(u), d = (l) => {
+    t({
+      ...o,
+      minimumColumnWidth: [l, i].join("")
+    });
+  }, x = (l) => {
+    let r;
+    ["em", "rem"].includes(l) && i === "px" ? r = (n / 16).toFixed(2) + l : ["em", "rem"].includes(i) && l === "px" && (r = Math.round(n * 16) + l), t({
+      ...o,
+      minimumColumnWidth: r
+    });
+  };
+  return /* @__PURE__ */ e.jsxs("fieldset", {
+    children: [/* @__PURE__ */ e.jsx(g.VisualLabel, {
+      as: "legend",
+      children: s("Minimum column width")
+    }), /* @__PURE__ */ e.jsxs(v, {
+      gap: 4,
+      children: [/* @__PURE__ */ e.jsx(h, {
+        isBlock: !0,
+        children: /* @__PURE__ */ e.jsx(S, {
+          size: "__unstable-large",
+          onChange: (l) => {
+            t({
+              ...o,
+              minimumColumnWidth: l === "" ? void 0 : l
+            });
+          },
+          onUnitChange: x,
+          value: u,
+          units: N,
+          min: 0,
+          label: s("Minimum column width"),
+          hideLabelFromVision: !0
+        })
+      }), /* @__PURE__ */ e.jsx(h, {
+        isBlock: !0,
+        children: /* @__PURE__ */ e.jsx(G, {
+          __next40pxDefaultSize: !0,
+          __nextHasNoMarginBottom: !0,
+          onChange: d,
+          value: n || 0,
+          min: 0,
+          max: z[i] || 600,
+          withInputField: !1,
+          label: s("Minimum column width"),
+          hideLabelFromVision: !0
+        })
+      })]
+    })]
+  });
+}
+function W({
+  layout: o,
+  onChange: t,
+  allowSizingOnChildren: a
+}) {
+  const c = window.__experimentalEnableGridInteractivity ? void 0 : 3, {
+    columnCount: m = c,
+    rowCount: p,
+    isManualPlacement: u
+  } = o;
+  return /* @__PURE__ */ e.jsx(e.Fragment, {
+    children: /* @__PURE__ */ e.jsxs("fieldset", {
+      children: [(!window.__experimentalEnableGridInteractivity || !u) && /* @__PURE__ */ e.jsx(g.VisualLabel, {
+        as: "legend",
+        children: s("Columns")
+      }), /* @__PURE__ */ e.jsxs(v, {
+        gap: 4,
+        children: [/* @__PURE__ */ e.jsx(h, {
+          isBlock: !0,
+          children: /* @__PURE__ */ e.jsx(b, {
+            size: "__unstable-large",
+            onChange: (n) => {
+              if (window.__experimentalEnableGridInteractivity) {
+                const d = n === "" || n === "0" ? u ? 1 : void 0 : parseInt(n, 10);
+                t({
+                  ...o,
+                  columnCount: d
+                });
+              } else {
+                const i = n === "" || n === "0" ? 1 : parseInt(n, 10);
+                t({
+                  ...o,
+                  columnCount: i
+                });
+              }
+            },
+            value: m,
+            min: 1,
+            label: s("Columns"),
+            hideLabelFromVision: !window.__experimentalEnableGridInteractivity || !u
+          })
+        }), /* @__PURE__ */ e.jsx(h, {
+          isBlock: !0,
+          children: window.__experimentalEnableGridInteractivity && a && u ? /* @__PURE__ */ e.jsx(b, {
+            size: "__unstable-large",
+            onChange: (n) => {
+              const i = n === "" || n === "0" ? 1 : parseInt(n, 10);
+              t({
+                ...o,
+                rowCount: i
+              });
+            },
+            value: p,
+            min: 1,
+            label: s("Rows")
+          }) : /* @__PURE__ */ e.jsx(G, {
+            __next40pxDefaultSize: !0,
+            __nextHasNoMarginBottom: !0,
+            value: m ?? 1,
+            onChange: (n) => t({
+              ...o,
+              columnCount: n === "" || n === "0" ? 1 : n
+            }),
+            min: 1,
+            max: 16,
+            withInputField: !1,
+            label: s("Columns"),
+            hideLabelFromVision: !0
+          })
+        })]
+      })]
+    })
+  });
+}
+function B({
+  layout: o,
+  onChange: t
+}) {
+  const {
+    columnCount: a,
+    rowCount: c,
+    minimumColumnWidth: m,
+    isManualPlacement: p
+  } = o, [u, n] = _(a || 3), [i, d] = _(c), [x, l] = _(m || "12rem"), r = p || a && !window.__experimentalEnableGridInteractivity ? "manual" : "auto", f = (C) => {
+    C === "manual" ? l(m || "12rem") : (n(a || 3), d(c)), t({
+      ...o,
+      columnCount: C === "manual" ? u : null,
+      rowCount: C === "manual" && window.__experimentalEnableGridInteractivity ? i : void 0,
+      isManualPlacement: C === "manual" && window.__experimentalEnableGridInteractivity ? !0 : void 0,
+      minimumColumnWidth: C === "auto" ? x : null
+    });
+  }, j = r === "manual" ? s("Grid items can be manually placed in any position on the grid.") : s("Grid items are placed automatically depending on their order.");
+  return /* @__PURE__ */ e.jsxs(I, {
+    __next40pxDefaultSize: !0,
+    __nextHasNoMarginBottom: !0,
+    label: s("Grid item position"),
+    value: r,
+    onChange: f,
+    isBlock: !0,
+    help: window.__experimentalEnableGridInteractivity ? j : void 0,
+    children: [/* @__PURE__ */ e.jsx(w, {
+      value: "auto",
+      label: s("Auto")
+    }, "auto"), /* @__PURE__ */ e.jsx(w, {
+      value: "manual",
+      label: s("Manual")
+    }, "manual")]
+  });
+}
+export {
+  X as default
+};

package/dist/node_modules/@wordpress/block-editor/build-module/layouts/index.js

@@ -0,0 +1,15 @@
+import e from "./flex.js";
+import n from "./flow.js";
+import f from "./constrained.js";
+import i from "./grid.js";
+const o = [n, e, f, i];
+function y(t = "default") {
+  return o.find((r) => r.name === t);
+}
+function c() {
+  return o;
+}
+export {
+  y as getLayoutType,
+  c as getLayoutTypes
+};

package/dist/node_modules/@wordpress/block-editor/build-module/layouts/utils.js

@@ -0,0 +1,26 @@
+import { sprintf as m } from "../../../i18n/build-module/sprintf.js";
+import "../../../../tannin/index.js";
+import { __ as o } from "../../../i18n/build-module/default-i18n.js";
+import { LAYOUT_DEFINITIONS as d } from "./definitions.js";
+function f(n, t = "") {
+  return n.split(",").map((e) => `${e}${t ? ` ${t}` : ""}`).join(",");
+}
+function w(n, t = d, e, r) {
+  let i = "";
+  return t?.[e]?.spacingStyles?.length && r && t[e].spacingStyles.forEach((s) => {
+    i += `${f(n, s.selector.trim())} { `, i += Object.entries(s.rules).map(([c, v]) => `${c}: ${v || r}`).join("; "), i += "; }";
+  }), i;
+}
+function g(n) {
+  const {
+    contentSize: t,
+    wideSize: e,
+    type: r = "default"
+  } = n, i = {}, s = /^(?!0)\d+(px|em|rem|vw|vh|%|svw|lvw|dvw|svh|lvh|dvh|vi|svi|lvi|dvi|vb|svb|lvb|dvb|vmin|svmin|lvmin|dvmin|vmax|svmax|lvmax|dvmax)?$/i;
+  return s.test(t) && r === "constrained" && (i.none = m(o("Max %s wide"), t)), s.test(e) && (i.wide = m(o("Max %s wide"), e)), i;
+}
+export {
+  f as appendSelectors,
+  g as getAlignmentsInfo,
+  w as getBlockGapCSS
+};

package/dist/node_modules/@wordpress/block-editor/build-module/lock-unlock.js

@@ -0,0 +1,7 @@
+import { __dangerousOptInToUnstableAPIsOnlyForCoreModules as o } from "../../private-apis/build-module/implementation.js";
+const {
+  unlock: r
+} = o("I acknowledge private features are not for use in themes or plugins and doing so will break in the next version of WordPress.", "@wordpress/block-editor");
+export {
+  r as unlock
+};